wake-up-neo.com

Wählen Sie Zeilen aus einem DataFrame basierend auf Werten in einer Spalte in pandas aus.

Wie wählt man Zeilen aus einem DataFrame basierend auf Werten in einer Spalte in Pandas aus?

In SQL würde ich verwenden:

SELECT *
FROM table
WHERE colume_name = some_value

Ich habe versucht, die pandas -Dokumentation zu lesen, habe aber die Antwort nicht sofort gefunden.

1506
szli

Um Zeilen auszuwählen, deren Spaltenwert einem Skalar entspricht, some_value, verwenden Sie ==:

df.loc[df['column_name'] == some_value]

Verwenden Sie isin, um Zeilen auszuwählen, deren Spaltenwert sich in einem iterierbaren Wert befindet, some_values:

df.loc[df['column_name'].isin(some_values)]

Kombiniere mehrere Bedingungen mit &:

df.loc[(df['column_name'] >= A) & (df['column_name'] <= B)]

Beachten Sie die Klammern. Aufgrund der Python-Operator-Prioritätsregeln wird & enger gebunden als <= und >=. Daher sind die Klammern im letzten Beispiel erforderlich. Ohne die Klammern

df['column_name'] >= A & df['column_name'] <= B

wird analysiert als

df['column_name'] >= (A & df['column_name']) <= B

was zu einem Wahrheitswert einer Reihe führt, ist ein mehrdeutiger Fehler .


Verwenden Sie some_value, um Zeilen auszuwählen, deren Spaltenwert ngleich!= ist:

df.loc[df['column_name'] != some_value]

isin gibt eine Boolesche Reihe zurück. Um also Zeilen auszuwählen, deren Wert nicht ​​in some_values ist, negieren Sie die Boolesche Reihe mit ~:

df.loc[~df['column_name'].isin(some_values)]

Zum Beispiel,

import pandas as pd
import numpy as np
df = pd.DataFrame({'A': 'foo bar foo bar foo bar foo foo'.split(),
                   'B': 'one one two three two two one three'.split(),
                   'C': np.arange(8), 'D': np.arange(8) * 2})
print(df)
#      A      B  C   D
# 0  foo    one  0   0
# 1  bar    one  1   2
# 2  foo    two  2   4
# 3  bar  three  3   6
# 4  foo    two  4   8
# 5  bar    two  5  10
# 6  foo    one  6  12
# 7  foo  three  7  14

print(df.loc[df['A'] == 'foo'])

ausbeuten

     A      B  C   D
0  foo    one  0   0
2  foo    two  2   4
4  foo    two  4   8
6  foo    one  6  12
7  foo  three  7  14

Wenn Sie über mehrere Werte verfügen, die Sie einschließen möchten, fügen Sie diese in eine Liste ein (oder generell in eine beliebige iterative Liste) und verwenden Sie isin:

print(df.loc[df['B'].isin(['one','three'])])

ausbeuten

     A      B  C   D
0  foo    one  0   0
1  bar    one  1   2
3  bar  three  3   6
6  foo    one  6  12
7  foo  three  7  14

Beachten Sie jedoch, dass es effizienter ist, zuerst einen Index zu erstellen und dann df.loc zu verwenden, wenn Sie dies häufig tun möchten:

df = df.set_index(['B'])
print(df.loc['one'])

ausbeuten

       A  C   D
B              
one  foo  0   0
one  bar  1   2
one  foo  6  12

oder, um mehrere Werte aus dem Index aufzunehmen, verwenden Sie df.index.isin:

df.loc[df.index.isin(['one','two'])]

ausbeuten

       A  C   D
B              
one  foo  0   0
one  bar  1   2
two  foo  2   4
two  foo  4   8
two  bar  5  10
one  foo  6  12
2910
unutbu

tl; dr

Das pandas entspricht

select * from table where column_name = some_value

ist

table[table.column_name == some_value]

Mehrere Bedingungen:

table[(table.column_name == some_value) | (table.column_name2 == some_value2)]

oder

table.query('column_name == some_value | column_name2 == some_value2')

Codebeispiel

import pandas as pd

# Create data set
d = {'foo':[100, 111, 222], 
     'bar':[333, 444, 555]}
df = pd.DataFrame(d)

# Full dataframe:
df

# Shows:
#    bar   foo 
# 0  333   100
# 1  444   111
# 2  555   222

# Output only the row(s) in df where foo is 222:
df[df.foo == 222]

# Shows:
#    bar  foo
# 2  555  222

Im obigen Code gibt die Zeile df[df.foo == 222] die Zeilen basierend auf dem Spaltenwert an, in diesem Fall 222.

Es sind auch mehrere Bedingungen möglich:

df[(df.foo == 222) | (df.bar == 444)]
#    bar  foo
# 1  444  111
# 2  555  222

An diesem Punkt würde ich jedoch empfehlen, die Funktion query zu verwenden, da sie weniger ausführlich ist und dasselbe Ergebnis liefert:

df.query('foo == 222 | bar == 444')
237
imolit

Es gibt verschiedene Möglichkeiten, Zeilen aus einem pandas Datenrahmen auszuwählen:

  1. Boolesche Indizierung (df[df['col'] == value])
  2. Positionsindizierung (df.iloc[...])
  3. Label-Indexierung (df.xs(...))
  4. df.query(...) API

Im Folgenden zeige ich Ihnen Beispiele von jedem, mit Ratschlägen, wann bestimmte Techniken anzuwenden sind. Angenommen, unser Kriterium ist Spalte 'A' == 'foo'

(Hinweis zur Leistung: Für jeden Basistyp können wir die Dinge einfach halten, indem wir die API pandas verwenden, oder wir können außerhalb der API vorgehen, in der Regel numpy, und die Dinge beschleunigen.)


Setup
Zuerst müssen wir eine Bedingung identifizieren, die als unser Kriterium für die Auswahl von Zeilen dient. Wir werden mit dem Fall column_name == some_value des OP beginnen und einige andere häufige Anwendungsfälle einschließen.

Ausleihen bei @unutbu:

import pandas as pd, numpy as np

df = pd.DataFrame({'A': 'foo bar foo bar foo bar foo foo'.split(),
                   'B': 'one one two three two two one three'.split(),
                   'C': np.arange(8), 'D': np.arange(8) * 2})

1. Boolesche Indizierung

... Boolesche Indizierung erfordert, dass der wahre Wert der 'A'-Spalte jeder Zeile gleich 'foo' ist, und anschließend anhand dieser Wahrheitswerte ermittelt wird, welche Zeilen beibehalten werden sollen. Normalerweise nennen wir diese Reihe, ein Array von Wahrheitswerten, mask. Das machen wir auch hier.

mask = df['A'] == 'foo'

Mit dieser Maske können wir dann den Datenrahmen aufteilen oder indizieren

df[mask]

     A      B  C   D
0  foo    one  0   0
2  foo    two  2   4
4  foo    two  4   8
6  foo    one  6  12
7  foo  three  7  14

Dies ist eine der einfachsten Methoden, um diese Aufgabe zu erledigen. Wenn Leistung oder Intuitivität keine Rolle spielen, sollte dies die von Ihnen gewählte Methode sein. Wenn jedoch die Leistung ein Problem darstellt, sollten Sie eine alternative Methode zum Erstellen von mask in Betracht ziehen.


2. Positionsindizierung

Die Positionsindizierung (df.iloc[...]) hat ihre Anwendungsfälle, aber dies ist keiner von ihnen. Um herauszufinden, wo ein Slice erstellt werden soll, müssen wir zunächst die oben beschriebene Boolesche Analyse durchführen. Dies lässt uns einen zusätzlichen Schritt ausführen, um dieselbe Aufgabe zu erfüllen.

mask = df['A'] == 'foo'
pos = np.flatnonzero(mask)
df.iloc[pos]

     A      B  C   D
0  foo    one  0   0
2  foo    two  2   4
4  foo    two  4   8
6  foo    one  6  12
7  foo  three  7  14

3. Etikettenindizierung

Label Indexierung kann sehr praktisch sein, aber in diesem Fall machen wir wieder mehr Arbeit ohne Nutzen

df.set_index('A', append=True, drop=False).xs('foo', level=1)

     A      B  C   D
0  foo    one  0   0
2  foo    two  2   4
4  foo    two  4   8
6  foo    one  6  12
7  foo  three  7  14

4. df.query() API

pd.DataFrame.query ist eine sehr elegante/intuitive Methode, um diese Aufgabe auszuführen, ist jedoch häufig langsamer. Wenn Sie jedoch bei großen Datenmengen die folgenden Zeitvorgaben beachten , ist die Abfrage sehr effizient. Mehr als der Standardansatz und von ähnlicher Größenordnung wie mein bester Vorschlag.

df.query('A == "foo"')

     A      B  C   D
0  foo    one  0   0
2  foo    two  2   4
4  foo    two  4   8
6  foo    one  6  12
7  foo  three  7  14

Ich bevorzuge die Verwendung von Booleanmask

Tatsächliche Verbesserungen können vorgenommen werden, indem geändert wird, wie wir unser Booleanmask erstellen.

mask Alternative 1
Verwenden Sie das zugrunde liegende numpy-Array und verzichten Sie auf den Aufwand beim Erstellen eines anderen pd.Series

mask = df['A'].values == 'foo'

Ich werde am Ende ausführlichere Zeittests zeigen, aber werfen Sie einen Blick auf die Leistungssteigerungen, die wir mit dem Beispieldatenrahmen erzielen. Zunächst betrachten wir den Unterschied bei der Erstellung der mask

%timeit mask = df['A'].values == 'foo'
%timeit mask = df['A'] == 'foo'

5.84 µs ± 195 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)
166 µs ± 4.45 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)

Das Auswerten von mask mit dem Array numpy ist ~ 30-mal schneller. Dies liegt zum Teil daran, dass die Auswertung von numpy häufig schneller ist. Dies ist auch teilweise auf den fehlenden Overhead zurückzuführen, der zum Erstellen eines Index und eines entsprechenden pd.Series-Objekts erforderlich ist.

Als nächstes betrachten wir den Zeitpunkt für das Schneiden mit einem mask im Vergleich zum anderen.

mask = df['A'].values == 'foo'
%timeit df[mask]
mask = df['A'] == 'foo'
%timeit df[mask]

219 µs ± 12.3 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
239 µs ± 7.03 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

Die Leistungssteigerungen sind nicht so ausgeprägt. Wir werden sehen, ob dies bei robusteren Tests Bestand hat.


mask Alternative 2
Wir hätten auch den Datenrahmen rekonstruieren können. Bei der Rekonstruktion eines Datenrahmens gibt es eine große Einschränkung - Sie müssen sich dabei um dtypes kümmern!

Anstelle von df[mask] werden wir dies tun

pd.DataFrame(df.values[mask], df.index[mask], df.columns).astype(df.dtypes)

Wenn der Datenrahmen vom gemischten Typ ist (wie in unserem Beispiel), hat das resultierende Array beim Abrufen von df.values den Wert dtypeobject, und folglich haben alle Spalten des neuen Datenrahmens den Wert dtypeobject. Dies erfordert die Funktion astype(df.dtypes) und eliminiert potenzielle Leistungsgewinne.

%timeit df[m]
%timeit pd.DataFrame(df.values[mask], df.index[mask], df.columns).astype(df.dtypes)

216 µs ± 10.4 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
1.43 ms ± 39.6 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

Wenn der Datenrahmen jedoch kein gemischter Typ ist, ist dies eine sehr nützliche Methode.

Gegeben

np.random.seed([3,1415])
d1 = pd.DataFrame(np.random.randint(10, size=(10, 5)), columns=list('ABCDE'))

d1

   A  B  C  D  E
0  0  2  7  3  8
1  7  0  6  8  6
2  0  2  0  4  9
3  7  3  2  4  3
4  3  6  7  7  4
5  5  3  7  5  9
6  8  7  6  4  7
7  6  2  6  6  5
8  2  8  7  5  8
9  4  7  6  1  5    

%%timeit
mask = d1['A'].values == 7
d1[mask]

179 µs ± 8.73 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)

Versus

%%timeit
mask = d1['A'].values == 7
pd.DataFrame(d1.values[mask], d1.index[mask], d1.columns)

87 µs ± 5.12 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)

Wir haben die Zeit halbiert.


mask Alternative 3
@ unutbu zeigt uns auch, wie wir pd.Series.isin verwenden, um zu berücksichtigen, dass jedes Element von df['A'] in einer Reihe von Werten enthalten ist. Dies ergibt dasselbe Ergebnis, wenn unser Wertesatz ein Wertesatz ist, nämlich 'foo'. Es wird jedoch auch verallgemeinert, größere Mengen von Werten einzuschließen, wenn dies erforderlich ist. Es stellt sich heraus, dass dies immer noch ziemlich schnell ist, obwohl es eine allgemeinere Lösung ist. Der einzige wirkliche Verlust liegt in der Intuitivität für diejenigen, die mit dem Konzept nicht vertraut sind.

mask = df['A'].isin(['foo'])
df[mask]

     A      B  C   D
0  foo    one  0   0
2  foo    two  2   4
4  foo    two  4   8
6  foo    one  6  12
7  foo  three  7  14

Nach wie vor können wir jedoch numpy verwenden, um die Leistung zu verbessern und dabei so gut wie nichts zu opfern. Wir werden np.in1d verwenden

mask = np.in1d(df['A'].values, ['foo'])
df[mask]

     A      B  C   D
0  foo    one  0   0
2  foo    two  2   4
4  foo    two  4   8
6  foo    one  6  12
7  foo  three  7  14

Timing
Ich werde auch andere Konzepte aufnehmen, die in anderen Posts als Referenz erwähnt werden.
Code unten

Jede Spalte in dieser Tabelle stellt einen Datenrahmen unterschiedlicher Länge dar, über den wir jede Funktion testen. Jede Spalte zeigt die relative Zeit, wobei die schnellste Funktion einen Basisindex von 1.0 hat.

res.div(res.min())

                         10        30        100       300       1000      3000      10000     30000
mask_standard         2.156872  1.850663  2.034149  2.166312  2.164541  3.090372  2.981326  3.131151
mask_standard_loc     1.879035  1.782366  1.988823  2.338112  2.361391  3.036131  2.998112  2.990103
mask_with_values      1.010166  1.000000  1.005113  1.026363  1.028698  1.293741  1.007824  1.016919
mask_with_values_loc  1.196843  1.300228  1.000000  1.000000  1.038989  1.219233  1.037020  1.000000
query                 4.997304  4.765554  5.934096  4.500559  2.997924  2.397013  1.680447  1.398190
xs_label              4.124597  4.272363  5.596152  4.295331  4.676591  5.710680  6.032809  8.950255
mask_with_isin        1.674055  1.679935  1.847972  1.724183  1.345111  1.405231  1.253554  1.264760
mask_with_in1d        1.000000  1.083807  1.220493  1.101929  1.000000  1.000000  1.000000  1.144175

Sie werden feststellen, dass die schnellsten Zeiten offenbar zwischen mask_with_values und mask_with_in1d geteilt werden.

res.T.plot(loglog=True)

enter image description here

Funktionen

def mask_standard(df):
    mask = df['A'] == 'foo'
    return df[mask]

def mask_standard_loc(df):
    mask = df['A'] == 'foo'
    return df.loc[mask]

def mask_with_values(df):
    mask = df['A'].values == 'foo'
    return df[mask]

def mask_with_values_loc(df):
    mask = df['A'].values == 'foo'
    return df.loc[mask]

def query(df):
    return df.query('A == "foo"')

def xs_label(df):
    return df.set_index('A', append=True, drop=False).xs('foo', level=-1)

def mask_with_isin(df):
    mask = df['A'].isin(['foo'])
    return df[mask]

def mask_with_in1d(df):
    mask = np.in1d(df['A'].values, ['foo'])
    return df[mask]

Testen

res = pd.DataFrame(
    index=[
        'mask_standard', 'mask_standard_loc', 'mask_with_values', 'mask_with_values_loc',
        'query', 'xs_label', 'mask_with_isin', 'mask_with_in1d'
    ],
    columns=[10, 30, 100, 300, 1000, 3000, 10000, 30000],
    dtype=float
)

for j in res.columns:
    d = pd.concat([df] * j, ignore_index=True)
    for i in res.index:a
        stmt = '{}(d)'.format(i)
        setp = 'from __main__ import d, {}'.format(i)
        res.at[i, j] = timeit(stmt, setp, number=50)

Spezielles Timing
Betrachten Sie den Sonderfall, wenn wir ein einzelnes Nicht-Objekt dtype für den gesamten Datenrahmen haben. Code unten

spec.div(spec.min())

                     10        30        100       300       1000      3000      10000     30000
mask_with_values  1.009030  1.000000  1.194276  1.000000  1.236892  1.095343  1.000000  1.000000
mask_with_in1d    1.104638  1.094524  1.156930  1.072094  1.000000  1.000000  1.040043  1.027100
reconstruct       1.000000  1.142838  1.000000  1.355440  1.650270  2.222181  2.294913  3.406735

Es stellt sich heraus, dass sich der Wiederaufbau nach ein paar hundert Reihen nicht mehr lohnt.

spec.T.plot(loglog=True)

enter image description here

Funktionen

np.random.seed([3,1415])
d1 = pd.DataFrame(np.random.randint(10, size=(10, 5)), columns=list('ABCDE'))

def mask_with_values(df):
    mask = df['A'].values == 'foo'
    return df[mask]

def mask_with_in1d(df):
    mask = np.in1d(df['A'].values, ['foo'])
    return df[mask]

def reconstruct(df):
    v = df.values
    mask = np.in1d(df['A'].values, ['foo'])
    return pd.DataFrame(v[mask], df.index[mask], df.columns)

spec = pd.DataFrame(
    index=['mask_with_values', 'mask_with_in1d', 'reconstruct'],
    columns=[10, 30, 100, 300, 1000, 3000, 10000, 30000],
    dtype=float
)

Testen

for j in spec.columns:
    d = pd.concat([df] * j, ignore_index=True)
    for i in spec.index:
        stmt = '{}(d)'.format(i)
        setp = 'from __main__ import d, {}'.format(i)
        spec.at[i, j] = timeit(stmt, setp, number=50)
192
piRSquared

Ich finde die Syntax der vorherigen Antworten überflüssig und schwer zu merken. Pandas hat die Methode query() in Version 0.13 eingeführt, und ich bevorzuge sie sehr. Für Ihre Frage können Sie df.query('col == val')

Wiedergabe von http://pandas.pydata.org/pandas-docs/version/0.17.0/indexing.html#indexing-query

In [167]: n = 10

In [168]: df = pd.DataFrame(np.random.Rand(n, 3), columns=list('abc'))

In [169]: df
Out[169]: 
          a         b         c
0  0.687704  0.582314  0.281645
1  0.250846  0.610021  0.420121
2  0.624328  0.401816  0.932146
3  0.011763  0.022921  0.244186
4  0.590198  0.325680  0.890392
5  0.598892  0.296424  0.007312
6  0.634625  0.803069  0.123872
7  0.924168  0.325076  0.303746
8  0.116822  0.364564  0.454607
9  0.986142  0.751953  0.561512

# pure python
In [170]: df[(df.a < df.b) & (df.b < df.c)]
Out[170]: 
          a         b         c
3  0.011763  0.022921  0.244186
8  0.116822  0.364564  0.454607

# query
In [171]: df.query('(a < b) & (b < c)')
Out[171]: 
          a         b         c
3  0.011763  0.022921  0.244186
8  0.116822  0.364564  0.454607

Sie können auch auf Variablen in der Umgebung zugreifen, indem Sie @ voranstellen.

exclude = ('red', 'orange')
df.query('color not in @exclude')
51
fredcallaway

Schnellere Ergebnisse können mit numpy.where erzielt werden.

Zum Beispiel mit nubtu's setup -

In [76]: df.iloc[np.where(df.A.values=='foo')]
Out[76]: 
     A      B  C   D
0  foo    one  0   0
2  foo    two  2   4
4  foo    two  4   8
6  foo    one  6  12
7  foo  three  7  14

Timing-Vergleiche:

In [68]: %timeit df.iloc[np.where(df.A.values=='foo')]  # fastest
1000 loops, best of 3: 380 µs per loop

In [69]: %timeit df.loc[df['A'] == 'foo']
1000 loops, best of 3: 745 µs per loop

In [71]: %timeit df.loc[df['A'].isin(['foo'])]
1000 loops, best of 3: 562 µs per loop

In [72]: %timeit df[df.A=='foo']
1000 loops, best of 3: 796 µs per loop

In [74]: %timeit df.query('(A=="foo")')  # slowest
1000 loops, best of 3: 1.71 ms per loop
18
shivsn

Hier ist ein einfaches Beispiel

from pandas import DataFrame

# Create data set
d = {'Revenue':[100,111,222], 
     'Cost':[333,444,555]}
df = DataFrame(d)


# mask = Return True when the value in column "Revenue" is equal to 111
mask = df['Revenue'] == 111

print mask

# Result:
# 0    False
# 1     True
# 2    False
# Name: Revenue, dtype: bool


# Select * FROM df WHERE Revenue = 111
df[mask]

# Result:
#    Cost    Revenue
# 1  444     111
16
DataByDavid

So wählen Sie nur bestimmte Spalten aus mehreren Spalten für einen bestimmten Wert in pandas aus:

select col_name1, col_name2 from table where column_name = some_value.

Optionen:

df.loc[df['column_name'] == some_value][[col_name1, col_name2]]

oder

df.query['column_name' == 'some_value'][[col_name1, col_name2]]
12
SP001

Ich habe gerade versucht, dies zu bearbeiten, war aber nicht angemeldet, daher bin ich mir nicht sicher, wohin meine Bearbeitung ging. Ich habe versucht, die Mehrfachauswahl einzubeziehen. Ich denke, eine bessere Antwort ist:

Für einen einzelnen Wert ist der einfachste (vom Menschen lesbare) wahrscheinlich:

df.loc[df['column_name'] == some_value]

Für Wertelisten können Sie auch Folgendes verwenden:

df.loc[df['column_name'].isin(some_values)]

Zum Beispiel,

import pandas as pd
import numpy as np
df = pd.DataFrame({'A': 'foo bar foo bar foo bar foo foo'.split(),
               'B': 'one one two three two two one three'.split(),
               'C': np.arange(8), 'D': np.arange(8) * 2})
print(df)
#      A      B  C   D
# 0  foo    one  0   0
# 1  bar    one  1   2
# 2  foo    two  2   4
# 3  bar  three  3   6
# 4  foo    two  4   8
# 5  bar    two  5  10
# 6  foo    one  6  12
# 7  foo  three  7  14

print(df.loc[df['A'] == 'foo'])

ausbeuten

     A      B  C   D
0  foo    one  0   0
2  foo    two  2   4
4  foo    two  4   8
6  foo    one  6  12
7  foo  three  7  14

Wenn Sie mehrere Kriterien auswählen möchten, können Sie diese in eine Liste aufnehmen und 'isin' verwenden:

print(df.loc[df['B'].isin(['one','three'])])

ausbeuten

      A      B  C   D
0  foo    one  0   0
1  bar    one  1   2
3  bar  three  3   6
6  foo    one  6  12
7  foo  three  7  14

Beachten Sie jedoch, dass es effizienter ist, zuerst A als Index festzulegen und dann df.loc zu verwenden, wenn Sie dies mehrmals tun möchten:

df = df.set_index(['A'])
print(df.loc['foo'])

ausbeuten

  A      B  C   D
foo    one  0   0
foo    two  2   4
foo    two  4   8
foo    one  6  12
foo  three  7  14
11
Jeff Ellen

Um an diese berühmte Frage anzuhängen (wenn auch etwas zu spät): Sie können auch df.groupby('column_name').get_group('column_desired_value').reset_index() ausführen, um einen neuen Datenrahmen mit einer bestimmten Spalte mit einem bestimmten Wert zu erstellen. Z.B.

import pandas as pd
df = pd.DataFrame({'A': 'foo bar foo bar foo bar foo foo'.split(),
                   'B': 'one one two three two two one three'.split()})
print("Original dataframe:")
print(df)

b_is_two_dataframe = pd.DataFrame(df.groupby('B').get_group('two').reset_index()).drop('index', axis = 1) 
#NOTE: the final drop is to remove the extra index column returned by groupby object
print('Sub dataframe where B is two:')
print(b_is_two_dataframe)

Führen Sie dies ergibt:

Original dataframe:
     A      B
0  foo    one
1  bar    one
2  foo    two
3  bar  three
4  foo    two
5  bar    two
6  foo    one
7  foo  three
Sub dataframe where B is two:
     A    B
0  foo  two
1  foo  two
2  bar  two
9
TuanDT

Wenn Sie Zeilen finden, die auf einer Ganzzahl in einer Spalte basieren, dann

df.loc[df['column_name'] == 2017]

Wenn Sie einen Wert basierend auf einer Zeichenfolge finden

df.loc[df['column_name'] == 'string']

Wenn auf beidem basiert

df.loc[(df['column_name'] == 'string') & (df['column_name'] == 2017)]
8
prateek singh
df = pd.DataFrame({'A': 'foo bar foo bar foo bar foo foo'.split(),
                   'B': 'one one two three two two one three'.split(),
                   'C': np.arange(8), 'D': np.arange(8) * 2})
df[df['A']=='foo']

OUTPUT:
   A      B  C   D
0  foo    one  0   0
2  foo    two  2   4
4  foo    two  4   8
6  foo    one  6  12
7  foo  three  7  14
6
user15051990

Wenn Sie hierher gekommen sind, um Zeilen aus einem Datenframe auszuwählen, indem Sie diejenigen einschließen, deren Spaltenwert NICHT in einer Werteliste enthalten ist, können Sie die Antwort von unutbu auf eine Werteliste wie folgt umblättern:

df.loc[~df['column_name'].isin(some_values)]

(Um keinen einzelnen Wert einzuschließen, verwenden Sie einfach den regulären Nicht-Gleichheits-Operator !=.)

Beispiel:

import pandas as pd
df = pd.DataFrame({'A': 'foo bar foo bar foo bar foo foo'.split(),
                   'B': 'one one two three two two one three'.split()})
print(df)

gibt uns

     A      B
0  foo    one
1  bar    one
2  foo    two
3  bar  three
4  foo    two
5  bar    two
6  foo    one
7  foo  three    

So legen Sie nur die Zeilen fest, die NICHT one oder three in Spalte B sind:

df.loc[~df['B'].isin(['one', 'three'])]

ausbeuten

     A    B
2  foo  two
4  foo  two
5  bar  two
5
Bonnie

Mehr Flexibilität mit .query mit pandas >= 0.25.0:

August 2019 aktualisierte Antwort

Seit pandas >= 0.25.0 können wir die query -Methode verwenden, um Datenrahmen mit pandas -Methoden und sogar Spaltennamen mit Leerzeichen zu filtern. Normalerweise würden die Leerzeichen in den Spaltennamen einen Fehler ergeben, aber jetzt können wir das mit einem Backtick (`) lösen, siehe GitHub :

# Example dataframe
df = pd.DataFrame({'Sender email':['[email protected]', "[email protected]", "[email protected]"]})

     Sender email
0  [email protected]
1  [email protected]
2    [email protected]

Verwenden von .query mit der Methode str.endswith:

df.query('`Sender email`.str.endswith("@shop.com")')

Ausgabe

     Sender email
1  [email protected]
2    [email protected]

Wir können auch lokale Variablen verwenden, indem wir ein @ in unserer Abfrage voranstellen:

domain = 'shop.com'
df.query('`Sender email`.str.endswith(@domain)')

Ausgabe

     Sender email
1  [email protected]
2    [email protected]
3
Erfan

Sie können auch .apply verwenden:

df.apply(lambda row: row[df['B'].isin(['one','three'])])

Es funktioniert tatsächlich zeilenweise (d. H. Wendet die Funktion auf jede Zeile an).

Die Ausgabe ist

   A      B  C   D
0  foo    one  0   0
1  bar    one  1   2
3  bar  three  3   6
6  foo    one  6  12
7  foo  three  7  14

Das Ergebnis ist dasselbe wie bei Verwendung von @unutbu

df[[df['B'].isin(['one','three'])]]
2
Vahidn
df.loc[df['column_name'] == some_value]
1
John Nero