tutorial - python tabelle darstellen

tl; dr

Die Pandas entsprechen

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

In dem obigen Code ist es die Zeile df[df.foo == 222] , die die Zeilen basierend auf dem Spaltenwert df[df.foo == 222] , 222 in diesem Fall.

Mehrere Bedingungen sind ebenfalls möglich:

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

Aber an dieser Stelle würde ich empfehlen, die query verwenden, da sie weniger ausführlich ist und das gleiche Ergebnis liefert:

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

An diese berühmte Frage anhängen (wenn auch etwas zu spät): Sie können auch df.groupby('column_name').get_group('column_desired_value').reset_index() , um einen neuen df.groupby('column_name').get_group('column_desired_value').reset_index() 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 aus:

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

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

Ich finde die Syntax der vorherigen Antworten redundant und schwer zu merken. Pandas haben die Methode query() in v0.13 eingeführt und ich bevorzuge sie sehr. Für Ihre Frage könnten Sie df.query('col == val')

Reproduziert 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 ein @ voranstellen.

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

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

Zum Beispiel mit unubtus 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

Zeitvergleiche:

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

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

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

Um Zeilen auszuwählen, deren Spaltenwert sich in einem some_values , verwenden Sie isin :

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

Kombiniere mehrere Bedingungen mit & :

df.loc[(df['column_name'] == some_value) & df['other_column'].isin(some_values)]

Um Zeilen zu wählen, deren Spaltenwert nicht gleich some_value , verwenden Sie != :

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

isin gibt eine boolesche Reihe zurück. isin also Zeilen auszuwählen, deren Wert nicht in some_values , some_values die boolesche Reihe mit ~ :

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

Beispielsweise,

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'])

Erträge

     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 Werte haben, die Sie einschließen möchten, isin Sie sie in eine Liste (oder allgemeiner, alle iterierbaren) ein und verwenden Sie isin :

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

Erträge

     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 df.loc und dann df.loc , wenn Sie dies mehrmals tun df.loc :

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

Erträge

       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'])]

Erträge

       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

Wenn Sie hierher gekommen sind, um Zeilen aus einem Datenrahmen auszuwählen, indem Sie diejenigen einschließen, deren Spaltenwert KEINE Werte enthält, können Sie die Antwort von unutbu wie folgt umblättern:

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

(Um keinen einzelnen Wert anzugeben, verwenden Sie natürlich nur den regulären 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    

Um nur die Zeilen zu unterteilen, die NICHT one oder three in Spalte B :

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

Erträge

     A    B
2  foo  two
4  foo  two
5  bar  two

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