python - पांडा में कॉलम में मानों के आधार पर डेटाफ्रेम से पंक्तियों का चयन करें




pandas dataframe (10)

पांडा में कुछ कॉलम में मानों के आधार पर डेटाफ्रेम से पंक्तियों का चयन कैसे करें?
एसक्यूएल में मैं उपयोग करूंगा:

select * from table where colume_name = some_value. 

मैंने पांडा दस्तावेज देखने की कोशिश की लेकिन तुरंत जवाब नहीं मिला।


Answers

numpy.where का उपयोग कर तेजी से परिणाम प्राप्त किया जा सकता है।

उदाहरण के लिए, unubtu सेटअप के साथ -

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

समय की तुलना:

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

पांडा में दिए गए मान के लिए एकाधिक कॉलम से केवल विशिष्ट कॉलम चुनने के लिए:

select col_name1, col_name2 from table where column_name = some_value.

विकल्प:

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

या

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

यदि आप यहां डेटाफ्रेम से पंक्तियों का चयन करना चाहते हैं, जिनके कॉलम का मान मूल्यों की सूची में से कोई नहीं है, तो यहां ऊपर दिए गए मानों की सूची के लिए unutbu के उत्तर को फ़्लिप करने का तरीका बताया गया है:

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

(निश्चित रूप से एक मूल्य शामिल नहीं करने के लिए, आप नियमित रूप से नियमित रूप से ऑपरेटर के बराबर नहीं उपयोग करते हैं != ।)

उदाहरण:

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)

हमें देता है

     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    

केवल उन पंक्तियों को सब्सक्राइब करने के लिए जो कॉलम B में one या three नहीं हैं:

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

पैदावार

     A    B
2  foo  two
4  foo  two
5  bar  two

tl; डॉ

पांडा समकक्ष

select * from table where column_name = some_value

है

table[table.column_name == some_value]

कई स्थितियां:

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

या

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

कोड उदाहरण

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

उपर्युक्त कोड में यह लाइन df[df.foo == 222] जो इस मामले में कॉलम मान, 222 आधार पर पंक्तियां देता है।

कई स्थितियां भी संभव हैं:

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

लेकिन उस समय मैं query फ़ंक्शन का उपयोग करने की अनुशंसा करता हूं, क्योंकि यह कम वर्बोज़ है और उसी परिणाम को उत्पन्न करता है:

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

पांडा डेटाफ्रेम से पंक्तियों का चयन करने के कुछ बुनियादी तरीके हैं।

  1. बूलियन इंडेक्सिंग
  2. पोजिशनल इंडेक्सिंग
  3. लेबल इंडेक्सिंग
  4. एपीआई

प्रत्येक आधार प्रकार के लिए, हम अपने आप को पांडा एपीआई में सीमित करके चीजों को सरल बना सकते हैं या हम एपीआई के बाहर उद्यम कर सकते हैं, आमतौर पर numpy , और गति चीजों को ऊपर।

मैं आपको प्रत्येक के उदाहरण दिखाऊंगा और आपको कुछ तकनीकों का उपयोग करने के लिए मार्गदर्शन करूंगा।

सेट अप
पहली चीज़ जो हमें चाहिए वह ऐसी स्थिति की पहचान करना है जो पंक्तियों का चयन करने के लिए हमारे मानदंड के रूप में कार्य करेगी। ओपी column_name == some_value प्रदान करता है। हम वहां शुरू करेंगे और कुछ अन्य सामान्य उपयोग मामलों को शामिल करेंगे।

@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})

मान लें कि हमारा मानदंड स्तंभ 'A' = 'foo'

1।
बूलियन इंडेक्सिंग को प्रत्येक पंक्ति के 'A' कॉलम के सत्य मूल्य को 'foo' बराबर होने की आवश्यकता होती है, फिर उन सत्य मानों का उपयोग करके यह पता लगाने के लिए कि कौन सी पंक्तियां रखना है। आम तौर पर, हम इस श्रृंखला का नाम, सत्य मूल्यों, mask की एक सरणी का नाम देंगे। हम यहां भी ऐसा करेंगे।

mask = df['A'] == '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

यह इस कार्य को पूरा करने के सबसे सरल तरीकों में से एक है और यदि प्रदर्शन या अंतर्ज्ञान कोई मुद्दा नहीं है, तो यह आपकी चुनी विधि होनी चाहिए। हालांकि, यदि प्रदर्शन एक चिंता है, तो आप mask बनाने का एक वैकल्पिक तरीका विचार करना चाहेंगे।

2।
पोजिशनल इंडेक्सिंग के उपयोग के मामले हैं, लेकिन यह उनमें से एक नहीं है। स्लाइस कहां से पहचानने के लिए, हमें पहले उसी बूलियन विश्लेषण को करने की आवश्यकता है जो हमने ऊपर किया था। यह हमें एक ही कार्य को पूरा करने के लिए एक अतिरिक्त कदम प्रदर्शन करता है।

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।
लेबल इंडेक्सिंग बहुत आसान हो सकती है, लेकिन इस मामले में, हम फिर से लाभ के लिए और अधिक काम कर रहे हैं

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।
pd.DataFrame.query इस कार्य को करने के लिए एक बहुत ही सुरुचिपूर्ण / सहज ज्ञान युक्त तरीका है। लेकिन अक्सर धीमा होता है। हालांकि , यदि आप बड़े डेटा के लिए नीचे दिए गए समय पर ध्यान देते हैं, तो क्वेरी बहुत ही कुशल है। मेरे सर्वोत्तम सुझाव के रूप में मानक दृष्टिकोण और समान परिमाण से कहीं अधिक।

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

मेरी प्राथमिकता Boolean mask का उपयोग करना mask

संशोधित करके वास्तविक सुधार किए जा सकते हैं कि हम अपने Boolean mask कैसे बनाते हैं।

mask विकल्प 1
अंतर्निहित numpy सरणी का प्रयोग करें और एक और pd.Series बनाने के ऊपरी हिस्से से pd.Series

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

मैं अंत में अधिक पूर्णकालिक परीक्षण दिखाऊंगा, लेकिन नमूना डेटाफ्रेम का उपयोग करके हमें प्राप्त होने वाले प्रदर्शन लाभों पर नज़र डालें। सबसे पहले हम mask बनाने में अंतर देखते 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)

numpy सरणी के साथ mask मूल्यांकन ~ 30 गुना तेजी से है। यह आंशिक रूप से numpy मूल्यांकन के कारण अक्सर तेज़ होता है। यह आंशिक रूप से इंडेक्स और संबंधित pd.Series ऑब्जेक्ट बनाने के लिए आवश्यक ओवरहेड की कमी के कारण भी है।

इसके बाद हम एक mask बनाम दूसरे के साथ टुकड़े करने के लिए समय देखेंगे।

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)

प्रदर्शन लाभ स्पष्ट नहीं हैं। हम देखेंगे कि यह अधिक मजबूत परीक्षण पर निर्भर करता है या नहीं।

mask विकल्प 2
हम डेटाफ्रेम का पुनर्निर्माण भी कर सकते थे। dtypes का पुनर्निर्माण करते समय एक बड़ी चेतावनी है-ऐसा करने पर आपको dtypes का ख्याल रखना चाहिए!

df[mask] बजाय हम यह करेंगे

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

यदि df.values मिश्रित प्रकार का है, जो हमारा उदाहरण है, तो जब हमें df.values मिलता है परिणामी सरणी dtype object और इसके परिणामस्वरूप, नए dtype सभी कॉलम dtype object । इस प्रकार astype(df.dtypes) आवश्यकता है और किसी भी संभावित प्रदर्शन लाभ की हत्या।

%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)

हालांकि, अगर डेटाफ्रेम मिश्रित प्रकार का नहीं है, तो यह करने का यह एक बहुत ही उपयोगी तरीका है।

दिया हुआ

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)

बनाम

%%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)

हम समय आधे में कटौती।

mask विकल्प 3
@unutbu हमें दिखाता है कि pd.Series.isin का उपयोग df['A'] प्रत्येक तत्व के मानों के सेट में होने के लिए खाते में कैसे किया pd.Series.isin । यह एक ही चीज़ का मूल्यांकन करता है यदि मूल्यों का हमारा सेट एक मान का एक सेट है, अर्थात् 'foo' । लेकिन यदि आवश्यक हो तो मूल्यों के बड़े सेट भी शामिल करना सामान्यीकृत है। बाहर निकलता है, यह अभी भी बहुत तेज़ है, भले ही यह एक सामान्य समाधान है। अवधारणा से परिचित लोगों के लिए एकमात्र वास्तविक हानि अंतर्ज्ञान में है।

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

हालांकि, पहले की तरह, हम लगभग कुछ भी sacraficing जबकि प्रदर्शन में सुधार करने के लिए numpy का उपयोग कर सकते हैं। हम np.in1d उपयोग np.in1d

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

समय
मैं संदर्भ के लिए अन्य पदों में उल्लिखित अन्य अवधारणाओं को भी शामिल करूंगा।
नीचे कोड

इस तालिका में प्रत्येक कॉलम एक अलग लंबाई डेटाफ्रेम का प्रतिनिधित्व करता है जिस पर हम प्रत्येक फ़ंक्शन का परीक्षण करते हैं। प्रत्येक कॉलम 1.0 बेस इंडेक्स को दिए गए सबसे तेज़ फ़ंक्शन के साथ सापेक्ष समय 1.0

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

आप देखेंगे कि सबसे तेज़ समय mask_with_values और mask_with_in1d बीच साझा किया mask_with_in1d

res.T.plot(loglog=True)

कार्य

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]

परिक्षण

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)

विशेष समय
विशेष dtype को देखते हुए जब हमारे पास संपूर्ण dtype लिए एक गैर-ऑब्जेक्ट dtypeनीचे कोड

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

बाहर निकलता है, पुनर्निर्माण कुछ सौ पंक्तियों के पीछे लायक नहीं है।

spec.T.plot(loglog=True)

कार्य

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
)

परिक्षण

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)

इस मशहूर प्रश्न (हालांकि थोड़ा देर हो चुकी है) में शामिल होने के लिए: आप df.groupby('column_name').get_group('column_desired_value').reset_index() भी कर सकते हैं df.groupby('column_name').get_group('column_desired_value').reset_index() निर्दिष्ट कॉलम के साथ एक विशेष डेटा वाले नए डेटा फ्रेम बनाने के लिए । उदाहरण के लिए

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)

इसे चलाएं:

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

मुझे पिछले उत्तरों के सिंटैक्स को अनावश्यक और याद रखना मुश्किल लगता है। पांडस ने v0.13 में query() विधि पेश की और मैं इसे बहुत पसंद करता हूं। आपके प्रश्न के लिए, आप df.query('col == val')

http://pandas.pydata.org/pandas-docs/version/0.17.0/indexing.html#indexing-query से पुन: 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

आप @ को प्रीपेड करके पर्यावरण में चर का उपयोग भी कर सकते हैं।

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

उन पंक्तियों का चयन करने के लिए जिनके कॉलम मान स्केलर के बराबर होते हैं, some_value value, == उपयोग करें:

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

उन पंक्तियों का चयन करने के लिए जिनके कॉलम मान एक पुनरावृत्त में हैं, some_values , isin उपयोग करें:

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

के साथ कई स्थितियों को मिलाएं & :

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

उन पंक्तियों का चयन करने के लिए जिनके कॉलम मान some_value value के बराबर नहीं हैं , का उपयोग करें != :

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

isin एक बुलियन श्रृंखला देता है, इसलिए पंक्तियों का चयन करने के लिए जिसका मूल्य some_values में नहीं है, बूलियन श्रृंखला का उपयोग करके ~

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

उदाहरण के लिए,

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

पैदावार

     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

यदि आपके पास एकाधिक मान हैं जिन्हें आप शामिल करना चाहते हैं, तो उन्हें एक सूची में रखें (या अधिक आम तौर पर, किसी भी पुनरावृत्त) और isin उपयोग करें:

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

पैदावार

     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

नोट, हालांकि, अगर आप इसे कई बार करना चाहते हैं, तो पहले इंडेक्स बनाने के लिए और अधिक कुशल है, और फिर df.loc उपयोग df.loc :

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

पैदावार

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

या, इंडेक्स उपयोग df.index.isin से एकाधिक मान शामिल करने के लिए:

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

पैदावार

       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

मैंने बस इसे संपादित करने का प्रयास किया, लेकिन मैं लॉग इन नहीं हुआ था, इसलिए मुझे यकीन नहीं है कि मेरा संपादन कहां चला गया। मैं एकाधिक चयन को शामिल करने की कोशिश कर रहा था। तो मुझे लगता है कि एक बेहतर जवाब है:

एक मूल्य के लिए, सबसे सरल (मानव पठनीय) शायद है:

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

मूल्यों की सूचियों के लिए आप इसका भी उपयोग कर सकते हैं:

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

उदाहरण के लिए,

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

पैदावार

     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

यदि आपके पास कई मानदंड हैं जिन्हें आप चुनना चाहते हैं, तो आप उन्हें एक सूची में डाल सकते हैं और 'isin' का उपयोग कर सकते हैं:

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

पैदावार

      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

नोट, हालांकि, अगर आप इसे कई बार करना चाहते हैं, तो पहले ए इंडेक्स बनाने के लिए और अधिक कुशल है, और फिर df.loc का उपयोग करें:

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

पैदावार

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

मुझे यह सवाल पता है और जवाब मौत के लिए चबाया गया है। लेकिन मैंने इसे किसी समस्या के लिए प्रेरणा के लिए संदर्भित किया था। मैं अलग-अलग उत्तरों से बिट्स और टुकड़ों का उपयोग करके इसे हल करने में सक्षम था इसलिए किसी को भी इसकी आवश्यकता होने पर मेरी प्रतिक्रिया प्रदान करना।

मेरी विधि सामान्य है जिसमें आप कम से कम delimiters= चर और भविष्य के सबूत को अलग करने के अल्पविराम जोड़ सकते हैं।

कार्य कोड:

import pandas as pd
import re


df = pd.DataFrame({'$a':[1,2], '$b': [3,4],'$c':[5,6], '$d': [7,8], '$e': [9,10]})

delimiters = '$'
matchPattern = '|'.join(map(re.escape, delimiters))
df.columns = [re.split(matchPattern, i)[1] for i in df.columns ]

आउटपुट:

>>> df
   $a  $b  $c  $d  $e
0   1   3   5   7   9
1   2   4   6   8  10

>>> df
   a  b  c  d   e
0  1  3  5  7   9
1  2  4  6  8  10




python pandas dataframe