python - Del df.column_name का उपयोग कर पांडा डेटाफ्रेम से कॉलम हटाएं




pandas dataframe (11)

पाइथन में सिंटैक्टिक सीमाओं के परिणामस्वरूप del df.column_name काम करना मुश्किल है। del df[name] पाइथन द्वारा कवर के तहत df.__delitem__(name) अनुवादित हो जाता है।

डेटाफ्रेम में कॉलम को हटाते समय मैं उपयोग करता हूं:

del df['column_name']

और यह बहुत अच्छा काम करता है। मैं इसका उपयोग क्यों नहीं कर सकता

del df.column_name

जैसा कि आप कॉलम / सीरीज़ को df.column_name रूप में एक्सेस कर सकते हैं, मैं उम्मीद करता हूं कि यह काम करे।


पांडा में 0.16.1+ आप केवल कॉलम छोड़ सकते हैं यदि वे @eiTanLaVi द्वारा पोस्ट किए गए समाधान के अनुसार मौजूद हैं। उस संस्करण से पहले, आप एक सशर्त सूची समझ के माध्यम से एक ही परिणाम प्राप्त कर सकते हैं:

df.drop([col for col in ['col_name_1','col_name_2',...,'col_name_N'] if col in df], 
        axis=1, inplace=True)

पांडस 0.21+ उत्तर

पांडो संस्करण 0.21 ने rename और reindex विधियों के हस्ताक्षर से मेल खाने के लिए index और columns पैरामीटर दोनों को शामिल करने के लिए ड्रॉप विधि को थोड़ा बदल दिया है।

df.drop(columns=['column_a', 'column_c'])

निजी तौर पर, मैं कॉलम या इंडेक्स को इंगित करने के लिए axis पैरामीटर का उपयोग करना पसंद करता हूं क्योंकि यह लगभग सभी पांडा विधियों में उपयोग किया जाने वाला मुख्य कीवर्ड पैरामीटर है। लेकिन, अब आपके पास संस्करण 0.21 में कुछ अतिरिक्त विकल्प हैं।


हमेशा [] नोटेशन का उपयोग करना अच्छा अभ्यास है, एक कारण यह है कि विशेषता नोटेशन ( df.column_name ) क्रमांकित सूचकांक के लिए काम नहीं करता है:

In [1]: df = DataFrame([[1, 2, 3], [4, 5, 6]])

In [2]: df[1]
Out[2]: 
0    2
1    5
Name: 1

In [3]: df.1
  File "<ipython-input-3-e4803c0d1066>", line 1
    df.1
       ^
SyntaxError: invalid syntax

एक अच्छा जोड़ा केवल कॉलम ड्रॉप करने की क्षमता है , यदि वे मौजूद हैं , इस तरह आप अधिक उपयोग मामलों को कवर कर सकते हैं, और यह केवल मौजूदा कॉलम को उस लेबल से हटा देगा:

बस त्रुटियों को जोड़ें = 'अनदेखा करें' , उदाहरण के लिए:

df.drop(['col_name_1','col_name_2',...,'col_name_N'],inplace=True,axis=1,errors='ignore')
  • यह पांडा 0.16.1 से नया है, दस्तावेज़ here

टी एल; डॉ

मामूली रूप से अधिक कुशल समाधान खोजने के लिए बहुत सारे प्रयास। df.drop(dlst, 1, errors='ignore') की सादगी को बलिदान करते हुए अतिरिक्त जटिलता को औचित्य देने में कठिनाई

df.reindex_axis(np.setdiff1d(df.columns.values, dlst), 1)

प्रस्तावना
कॉलम को हटाना अन्य कॉलम चुनने के समान ही है। मैं विचार करने के लिए कुछ अतिरिक्त तरीकों को दिखाऊंगा।

मैं एक साथ कई स्तंभों को हटाने के सामान्य समाधान पर भी ध्यान केंद्रित करूंगा और मौजूद कॉलम को हटाने का प्रयास करने की अनुमति नहीं दूंगा।

इन समाधानों का उपयोग सामान्य हैं और सरल मामले के लिए भी काम करेंगे।

सेट अप
pd.DataFrame df पर विचार करें और pd.DataFrame को हटाने के लिए सूची

df = pd.DataFrame(dict(zip('ABCDEFGHIJ', range(1, 11))), range(3))
dlst = list('HIJKLM')
df

   A  B  C  D  E  F  G  H  I   J
0  1  2  3  4  5  6  7  8  9  10
1  1  2  3  4  5  6  7  8  9  10
2  1  2  3  4  5  6  7  8  9  10
dlst

['H', 'I', 'J', 'K', 'L', 'M']

परिणाम इसकी तरह दिखना चाहिए:

df.drop(dlst, 1, errors='ignore')

   A  B  C  D  E  F  G
0  1  2  3  4  5  6  7
1  1  2  3  4  5  6  7
2  1  2  3  4  5  6  7

चूंकि मैं अन्य कॉलम चुनने के लिए कॉलम को हटाने के बराबर हूं, इसलिए मैं इसे दो प्रकारों में तोड़ दूंगा:

  1. लेबल चयन
  2. बूलियन चयन

चयन चयन करें

हम उन लेबलों की सूची / सरणी का निर्माण करके शुरू करते हैं जो कॉलम का प्रतिनिधित्व करते हैं जिन्हें हम रखना चाहते हैं और कॉलम के बिना जिन्हें हम हटाना चाहते हैं।

  1. df.columns.difference(dlst)

    Index(['A', 'B', 'C', 'D', 'E', 'F', 'G'], dtype='object')
    
  2. np.setdiff1d(df.columns.values, dlst)

    array(['A', 'B', 'C', 'D', 'E', 'F', 'G'], dtype=object)
    
  3. df.columns.drop(dlst, errors='ignore')

    Index(['A', 'B', 'C', 'D', 'E', 'F', 'G'], dtype='object')
    
  4. list(set(df.columns.values.tolist()).difference(dlst))

    # does not preserve order
    ['E', 'D', 'B', 'F', 'G', 'A', 'C']
    
  5. [x for x in df.columns.values.tolist() if x not in dlst]

    ['A', 'B', 'C', 'D', 'E', 'F', 'G']
    

लेबल से कॉलम
चयन प्रक्रिया की तुलना करने के लिए, मान लें:

 cols = [x for x in df.columns.values.tolist() if x not in dlst]

फिर हम मूल्यांकन कर सकते हैं

  1. df.loc[:, cols]
  2. df[cols]
  3. df.reindex(columns=cols)
  4. df.reindex_axis(cols, 1)

जो सभी का मूल्यांकन करते हैं:

   A  B  C  D  E  F  G
0  1  2  3  4  5  6  7
1  1  2  3  4  5  6  7
2  1  2  3  4  5  6  7

बूलियन स्लाइस

हम स्लाइसिंग के लिए बूलियन की एक सरणी / सूची बना सकते हैं

  1. ~df.columns.isin(dlst)
  2. ~np.in1d(df.columns.values, dlst)
  3. [x not in dlst for x in df.columns.values.tolist()]
  4. (df.columns.values[:, None] != dlst).all(1)

बूलियन से कॉलम
तुलना के लिए

bools = [x not in dlst for x in df.columns.values.tolist()]
  1. df.loc[: bools]

जो सभी का मूल्यांकन करते हैं:

   A  B  C  D  E  F  G
0  1  2  3  4  5  6  7
1  1  2  3  4  5  6  7
2  1  2  3  4  5  6  7

मजबूत समय

कार्य

setdiff1d = lambda df, dlst: np.setdiff1d(df.columns.values, dlst)
difference = lambda df, dlst: df.columns.difference(dlst)
columndrop = lambda df, dlst: df.columns.drop(dlst, errors='ignore')
setdifflst = lambda df, dlst: list(set(df.columns.values.tolist()).difference(dlst))
comprehension = lambda df, dlst: [x for x in df.columns.values.tolist() if x not in dlst]

loc = lambda df, cols: df.loc[:, cols]
slc = lambda df, cols: df[cols]
ridx = lambda df, cols: df.reindex(columns=cols)
ridxa = lambda df, cols: df.reindex_axis(cols, 1)

isin = lambda df, dlst: ~df.columns.isin(dlst)
in1d = lambda df, dlst: ~np.in1d(df.columns.values, dlst)
comp = lambda df, dlst: [x not in dlst for x in df.columns.values.tolist()]
brod = lambda df, dlst: (df.columns.values[:, None] != dlst).all(1)

परिक्षण

res1 = pd.DataFrame(
    index=pd.MultiIndex.from_product([
        'loc slc ridx ridxa'.split(),
        'setdiff1d difference columndrop setdifflst comprehension'.split(),
    ], names=['Select', 'Label']),
    columns=[10, 30, 100, 300, 1000],
    dtype=float
)

res2 = pd.DataFrame(
    index=pd.MultiIndex.from_product([
        'loc'.split(),
        'isin in1d comp brod'.split(),
    ], names=['Select', 'Label']),
    columns=[10, 30, 100, 300, 1000],
    dtype=float
)

res = res1.append(res2).sort_index()

dres = pd.Series(index=res.columns, name='drop')

for j in res.columns:
    dlst = list(range(j))
    cols = list(range(j // 2, j + j // 2))
    d = pd.DataFrame(1, range(10), cols)
    dres.at[j] = timeit('d.drop(dlst, 1, errors="ignore")', 'from __main__ import d, dlst', number=100)
    for s, l in res.index:
        stmt = '{}(d, {}(d, dlst))'.format(s, l)
        setp = 'from __main__ import d, dlst, {}, {}'.format(s, l)
        res.at[(s, l), j] = timeit(stmt, setp, number=100)

rs = res / dres
rs

                          10        30        100       300        1000
Select Label                                                           
loc    brod           0.747373  0.861979  0.891144  1.284235   3.872157
       columndrop     1.193983  1.292843  1.396841  1.484429   1.335733
       comp           0.802036  0.732326  1.149397  3.473283  25.565922
       comprehension  1.463503  1.568395  1.866441  4.421639  26.552276
       difference     1.413010  1.460863  1.587594  1.568571   1.569735
       in1d           0.818502  0.844374  0.994093  1.042360   1.076255
       isin           1.008874  0.879706  1.021712  1.001119   0.964327
       setdiff1d      1.352828  1.274061  1.483380  1.459986   1.466575
       setdifflst     1.233332  1.444521  1.714199  1.797241   1.876425
ridx   columndrop     0.903013  0.832814  0.949234  0.976366   0.982888
       comprehension  0.777445  0.827151  1.108028  3.473164  25.528879
       difference     1.086859  1.081396  1.293132  1.173044   1.237613
       setdiff1d      0.946009  0.873169  0.900185  0.908194   1.036124
       setdifflst     0.732964  0.823218  0.819748  0.990315   1.050910
ridxa  columndrop     0.835254  0.774701  0.907105  0.908006   0.932754
       comprehension  0.697749  0.762556  1.215225  3.510226  25.041832
       difference     1.055099  1.010208  1.122005  1.119575   1.383065
       setdiff1d      0.760716  0.725386  0.849949  0.879425   0.946460
       setdifflst     0.710008  0.668108  0.778060  0.871766   0.939537
slc    columndrop     1.268191  1.521264  2.646687  1.919423   1.981091
       comprehension  0.856893  0.870365  1.290730  3.564219  26.208937
       difference     1.470095  1.747211  2.886581  2.254690   2.050536
       setdiff1d      1.098427  1.133476  1.466029  2.045965   3.123452
       setdifflst     0.833700  0.846652  1.013061  1.110352   1.287831
fig, axes = plt.subplots(2, 2, figsize=(8, 6), sharey=True)
for i, (n, g) in enumerate([(n, g.xs(n)) for n, g in rs.groupby('Select')]):
    ax = axes[i // 2, i % 2]
    g.plot.bar(ax=ax, title=n)
    ax.legend_.remove()
fig.tight_layout()

यह df.drop(dlst, 1, errors='ignore') चलाने के लिए लगने वाले समय के सापेक्ष है df.drop(dlst, 1, errors='ignore') । ऐसा लगता है कि इस प्रयास के बाद, हम केवल मामूली प्रदर्शन में सुधार करते हैं।

यदि तथ्य सबसे अच्छा समाधान हैक list(set(df.columns.values.tolist()).difference(dlst)) पर reindex_axis या reindex_axis उपयोग करें list(set(df.columns.values.tolist()).difference(dlst))drop मुकाबले एक करीबी दूसरा और अभी भी बहुत मामूली बेहतर है np.setdiff1d

rs.idxmin().pipe(
    lambda x: pd.DataFrame(
        dict(idx=x.values, val=rs.lookup(x.values, x.index)),
        x.index
    )
)

                      idx       val
10     (ridx, setdifflst)  0.653431
30    (ridxa, setdifflst)  0.746143
100   (ridxa, setdifflst)  0.816207
300    (ridx, setdifflst)  0.780157
1000  (ridxa, setdifflst)  0.861622

डॉट सिंटैक्स जेएस में काम करता है लेकिन पायथन में नहीं।

पायथन : डेल डीएफ ['कॉलम_नाम']

जेएस : डेल डीएफ ['कॉलम_नाम'] या डेल df.column_name


सूचकांक द्वारा ड्रॉप

पहले, दूसरे और चौथे कॉलम हटाएं:

df.drop(df.columns[[0,1,3]], axis=1, inplace=True)

पहला कॉलम हटाएं:

df.drop(df.columns[[0]], axis=1, inplace=True)

एक वैकल्पिक पैरामीटर inplace ताकि मूल डेटा को प्रतिलिपि बनाये बिना संशोधित किया जा सके।

पॉपअप

कॉलम चयन, जोड़, हटाना

कॉलम column-name हटाएं:

df.pop('column-name')

उदाहरण:

df = DataFrame.from_items([('A', [1, 2, 3]), ('B', [4, 5, 6]), ('C', [7,8, 9])], orient='index', columns=['one', 'two', 'three'])

print df :

   one  two  three
A    1    2      3
B    4    5      6
C    7    8      9

df.drop(df.columns[[0]], axis=1, inplace=True)
print df :

   two  three
A    2      3
B    5      6
C    8      9

three = df.pop('three')
print df :

   two
A    2
B    5
C    8

संस्करण 0.16.1 से आप कर सकते हैं

df.drop(['column_name'], axis = 1, inplace = True, errors = 'ignore')

पांडा में ऐसा करने का सबसे अच्छा तरीका drop का उपयोग करना है:

df = df.drop('column_name', 1)

जहां 1 अक्ष संख्या है (पंक्तियों के लिए 0 और कॉलम के लिए 1 )

df को पुन: असाइन किए बिना कॉलम को हटाने के लिए आप कर सकते हैं:

df.drop('column_name', axis=1, inplace=True)

अंत में, कॉलम लेबल के बजाय कॉलम नंबर से ड्रॉप करने के लिए, इसे हटाने के लिए प्रयास करें, उदाहरण के लिए पहला, दूसरा और चौथा कॉलम:

df.drop(df.columns[[0, 1, 3]], axis=1)  # df.columns is zero-based pd.Index 

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




python pandas dataframe