जब एक DataFrame मैं उपयोग में एक कॉलम को हटाने:
del df['column_name']और यह बहुत अच्छा काम करता है। मैं निम्नलिखित का उपयोग क्यों नहीं कर सकता?
del df.column_nameचूंकि कॉलम / सीरीज को एक्सेस करना संभव है df.column_name, इसलिए मुझे उम्मीद है कि यह काम करेगा।
जवाबों:
जैसा कि आपने अनुमान लगाया है, सही सिंटैक्स है
del df['column_name']del df.column_nameपायथन में सिंटैक्टिक सीमाओं के परिणामस्वरूप काम करना मुश्किल है । अजगर द्वारा कवर के तहत del df[name]अनुवाद df.__delitem__(name)किया जाता है।
class A(object): def __init__(self): self.var = 1एक कक्षा स्थापित a = A(); del a.varकरता है , फिर ठीक काम करता है ...
del df[name], इसका अनुवाद हो जाता है, df.__delitem__(name)जो एक ऐसा तरीका है जिसे DataFrame अपनी आवश्यकताओं के अनुसार कार्यान्वित और संशोधित कर सकता है। के मामले में del df.name, सदस्य चर को बिना किसी कस्टम-कोड के चलने के अवसर के बिना हटा दिया जाता है। अपने स्वयं के उदाहरण पर विचार करें - क्या आप del a.var"डिलीट चर" के प्रिंट में परिणाम प्राप्त कर सकते हैं ? यदि आप कर सकते हैं, तो कृपया मुझे बताएं कि कैसे। मैं नहीं कर सकता :)
pandasडेवलपर्स ने नहीं किया , लेकिन इसका मतलब यह नहीं है कि यह करना मुश्किल है।
पंडों में ऐसा करने का सबसे अच्छा तरीका है drop:
df = df.drop('column_name', 1)अक्ष संख्या कहां 1है ( पंक्तियों के लिए और स्तंभों के लिए)01
पुन df: असाइन किए बिना स्तंभ को हटाने के लिए आप कर सकते हैं:
df.drop('column_name', axis=1, inplace=True)अंत में, कॉलम लेबल के बजाय कॉलम नंबर से ड्रॉप करने के लिए , इसे हटाने का प्रयास करें, जैसे कि 1, 2 और 4 वां कॉलम:
df = df.drop(df.columns[[0, 1, 3]], axis=1) # df.columns is zero-based pd.Index कॉलम के लिए "टेक्स्ट" सिंटैक्स के साथ काम करना:
df.drop(['column_nameA', 'column_nameB'], axis=1, inplace=True)delकिसी कारण के लिए सिफारिश की है ?
dropसे अधिक delहै कि dropआप करते हैं, एक साथ कई कॉलम ड्रॉप करने आपरेशन inplace या नहीं, और (विशेष रूप से या एक 3 डी मैट्रिक्स के लिए उपयोगी किसी भी अक्ष के साथ भी नष्ट रिकॉर्ड की अनुमति देता है Panel)
उपयोग:
columns = ['Col1', 'Col2', ...]
df.drop(columns, inplace=True, axis=1)यह एक या एक से अधिक कॉलम हटा देगा। ध्यान दें कि inplace=Trueपांडा v0.13 में जोड़ा गया था और पुराने संस्करणों पर काम नहीं करेगा। आपको उस मामले में परिणाम वापस सौंपना होगा:
df = df.drop(columns, axis=1)df.drop(list,inplace=True,axis=1)
del- एक बार में एक से अधिक स्तंभ गिरा सकता है।
पहले, दूसरे और चौथे कॉलम को हटाएं:
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 9df.drop(df.columns[[0]], axis=1, inplace=True)
print df:
two three
A 2 3
B 5 6
C 8 9three = df.pop('three')
print df:
two
A 2
B 5
C 8df.T.pop('A')
df। आप कर सकते हैं df = df.T; df.pop(index); df = df.Tलेकिन यह अत्यधिक लगता है।
df.drop(df.columns[[0]], axis=1, inplace=True)यह उपयोग करने के लिए पर्याप्त नहीं होगा df.drop([0], axis=1)?
0, तो df.drop(0, axis=1)अच्छी तरह से काम कर रहे हैं। लेकिन अगर आपको कॉलम का नाम नहीं पता है और पहले कॉलम को हटाना है तो जरूरत है df.drop(df.columns[[0]], axis=1, inplace=True), यह स्थिति के अनुसार पहला कॉलम चुनें और इसे छोड़ दें।
यहां अधिकांश उत्तरों से छूटा हुआ वास्तविक प्रश्न है:
del df.column_name?सबसे पहले हमें समस्या को समझने की जरूरत है, जिससे हमें अजगर के जादू के तरीकों में गोता लगाने की जरूरत है ।
जैसा कि वेस ने अपने उत्तर del df['column']मानचित्रों में अजगर जादू पद्धति को इंगित df.__delitem__('column')किया है जो स्तंभ को छोड़ने के लिए पांडा में लागू किया गया है
हालांकि, जैसा कि अजगर जादू विधियों के बारे में ऊपर दिए गए लिंक में बताया गया है :
वास्तव में,
__del__लगभग कभी भी उन अनिश्चित परिस्थितियों के कारण उपयोग नहीं किया जाना चाहिए जिनके तहत इसे कहा जाता है; सावधानी के साथ इसका उपयोग करें!
आप यह तर्क दे सकते हैं कि del df['column_name']इसका उपयोग नहीं किया जाना चाहिए या इसे प्रोत्साहित नहीं किया जाना चाहिए, और इस पर del df.column_nameभी विचार नहीं किया जाना चाहिए।
हालांकि, सिद्धांत रूप में, del df.column_nameका उपयोग करते हुए पांडा में काम करने के लिए किया जा सकता है implemeted जादू विधि । यह हालांकि कुछ समस्याओं, समस्याओं को लागू करता है जो कार्यान्वयन पहले से ही है, लेकिन कम डिग्री में।__delattr__del df['column_name']
क्या होगा यदि मैं "dtypes" या "कॉलम" नामक डेटाफ़्रेम में एक स्तंभ को परिभाषित करता हूं।
फिर मान लें कि मैं इन स्तंभों को हटाना चाहता हूं।
del df.dtypesहोगा __delattr__विधि उलझन में है कि यह "dtypes" विशेषता या "dtypes" कॉलम हटा देना चाहिए।
.ix, .locया .ilocतरीके।आप ऐसा नहीं कर सकते del df.column_nameक्योंकि पंडों के पास एक बेतहाशा विकसित वास्तुकला है जिसे इस तरह के संज्ञानात्मक असंगति के लिए पुनर्विचार करने की आवश्यकता है ताकि इसके उपयोगकर्ताओं को न हो।
Df.column_name का उपयोग न करें, यह सुंदर हो सकता है, लेकिन यह संज्ञानात्मक असंगति का कारण बनता है
स्तंभ को हटाने के कई तरीके हैं।
वहाँ एक होना चाहिए - और अधिमानतः यह करने के लिए केवल एक ही - स्पष्ट तरीका।
कॉलम कभी-कभी विशेषता होते हैं लेकिन कभी-कभी नहीं।
नियम तोड़ने के लिए विशेष मामले पर्याप्त नहीं हैं।
है del df.dtypesdtypes विशेषता या dtypes स्तंभ हटाना चाहते हैं?
अस्पष्टता के सामने, अनुमान लगाने के प्रलोभन से इनकार करें।
__del__लगभग कभी भी अनिश्चित परिस्थितियों के कारण उपयोग नहीं किया जाना चाहिए जिसके तहत इसे कहा जाता है; सावधानी के साथ इसका उपयोग करें!" यहाँ पूरी तरह से अप्रासंगिक है, क्योंकि यहाँ इस्तेमाल की जा रही विधि है __delattr__।
delअंतर्निहित .__del__विधि है , उदाहरण विधि नहीं है। delनिर्मित करने के लिए मैपिंग कर रहा है __delattr__और __delitem__जो है जो मैं पर मेरे तर्क का निर्माण कर रहा हूँ। इसलिए हो सकता है कि आपने जो लिखा है उसे फिर से पढ़ें।
__... __StackExchange द्वारा बोल्ड मार्कअप के रूप में intrerpreted हो जाता है
एक अच्छा जोड़ केवल स्तंभों को छोड़ने की क्षमता है यदि वे मौजूद हैं । इस तरह से आप अधिक उपयोग के मामलों को कवर कर सकते हैं, और यह केवल मौजूदा कॉलम को उसमें दिए गए लेबल से गिरा देगा:
उदाहरण के लिए, त्रुटियों को जोड़ें = 'अनदेखा करें' :
df.drop(['col_name_1', 'col_name_2', ..., 'col_name_N'], inplace=True, axis=1, errors='ignore')संस्करण 0.16.1 से आप कर सकते हैं
df.drop(['column_name'], axis = 1, inplace = True, errors = 'ignore')errors= 'ignore') df.drop(['column_1','column_2'], axis=1 , inplace=True,errors= 'ignore'), यदि ऐसा कोई एप्लिकेशन वांछित है!
हमेशा []नोटेशन का उपयोग करना अच्छा रहता है। एक कारण यह है कि 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पांडा संस्करण 0.21 बदल गया है dropथोड़ा विधि दोनों को शामिल करने indexऔर columnsमापदंडों के हस्ताक्षर से मेल करने के लिए renameऔर reindexतरीकों।
df.drop(columns=['column_a', 'column_c'])व्यक्तिगत रूप से, मैं axisकॉलम या इंडेक्स को दर्शाने के लिए पैरामीटर का उपयोग करना पसंद करता हूं क्योंकि यह लगभग सभी पंडों के तरीकों में उपयोग किया जाने वाला प्रमुख कीवर्ड पैरामीटर है। लेकिन, अब आपके पास संस्करण 0.21 में कुछ अतिरिक्त विकल्प हैं।
पांडा 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)थोड़ा और अधिक कुशल समाधान खोजने के लिए बहुत प्रयास। की सादगी का त्याग करते हुए जोड़े की जटिलता को उचित ठहराना मुश्किल हैdf.drop(dlst, 1, errors='ignore')
df.reindex_axis(np.setdiff1d(df.columns.values, dlst), 1)प्रस्तावना
हटाया जा रहा है एक स्तंभ शब्दार्थ अन्य स्तंभों का चयन के समान है। मैं विचार करने के लिए कुछ अतिरिक्त तरीके दिखाऊंगा।
मैं एक बार में कई कॉलम हटाने के सामान्य समाधान पर भी ध्यान केंद्रित करूंगा और कॉलम को न हटाने के प्रयास के लिए अनुमति दूंगा।
इन समाधानों का उपयोग करना सामान्य है और सरल मामले के लिए भी काम करेगा।
सेटअप हटाने के लिए सूची
पर विचार करेंpd.DataFrame dfdlst
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 10dlst
['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चूंकि मैं दूसरे कॉलम को चुनने के लिए एक कॉलम को हटाने के बराबर कर रहा हूं, इसलिए मैं इसे दो प्रकारों में तोड़ दूंगा:
हम उन लेबल की सूची / सरणी का निर्माण करके शुरू करते हैं जो उन स्तंभों का प्रतिनिधित्व करते हैं जिन्हें हम रखना चाहते हैं और उन स्तंभों के बिना जिन्हें हम हटाना चाहते हैं।
df.columns.difference(dlst)
Index(['A', 'B', 'C', 'D', 'E', 'F', 'G'], dtype='object')np.setdiff1d(df.columns.values, dlst)
array(['A', 'B', 'C', 'D', 'E', 'F', 'G'], dtype=object)df.columns.drop(dlst, errors='ignore')
Index(['A', 'B', 'C', 'D', 'E', 'F', 'G'], dtype='object')list(set(df.columns.values.tolist()).difference(dlst))
# does not preserve order
['E', 'D', 'B', 'F', 'G', 'A', 'C'][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]तब हम मूल्यांकन कर सकते हैं
df.loc[:, cols]df[cols]df.reindex(columns=cols)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हम टुकड़ा करने के लिए बूलियन की एक सरणी / सूची का निर्माण कर सकते हैं
~df.columns.isin(dlst)~np.in1d(df.columns.values, dlst)[x not in dlst for x in df.columns.values.tolist()](df.columns.values[:, None] != dlst).all(1)
तुलना के लिए बूलियन से कॉलम
bools = [x not in dlst for x in df.columns.values.tolist()]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 / dresrs
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.287831fig, 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')। ऐसा लगता है कि सभी प्रयासों के बाद, हम केवल प्रदर्शन में मामूली सुधार करते हैं।
अगर वास्तव में सबसे अच्छा समाधान का उपयोग करें reindexया 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 एक डेटाफ्रेम है।
स्तंभ हटाया जाना = कॉलम ०
कोड:
df = df.drop(column0, axis=1)कई कॉलम col1, col2 को हटाने के लिए। । । , कॉलन, हमें उन सभी कॉलमों को सम्मिलित करना होगा जिन्हें किसी सूची में निकालने की आवश्यकता है। फिर उन्हें ड्रॉप () विधि से हटा दें।
कोड:
df = df.drop([col1, col2, . . . , coln], axis=1)मुझे उम्मीद है कि यह मददगार होगा।
df = df.drop([col1, col2, . . . , coln], axis=1)यह काम नहीं करता है यदि मैं col1, col2 आदि के स्थान पर एक चर नाम निर्दिष्ट करता हूं, तो मुझे त्रुटि कॉलम मिलता है जब यह निश्चित रूप से मौजूद नहीं है। @ लिट्टिन क्या आपकी मदद कर सकता है?
पांडस डेटाफ़्रेम में एक कॉलम हटाने का दूसरा तरीका
यदि आप इन-प्लेस विलोपन की तलाश नहीं कर रहे हैं, तो आप DataFrame(...)फ़ंक्शन का उपयोग करके कॉलम निर्दिष्ट करके एक नया डेटाफ़्रेम बना सकते हैं
my_dict = { 'name' : ['a','b','c','d'], 'age' : [10,20,25,22], 'designation' : ['CEO', 'VP', 'MD', 'CEO']}
df = pd.DataFrame(my_dict)के रूप में एक नया DataFrame बनाएँ
newdf = pd.DataFrame(df, columns=['name', 'age'])आपको डेल / ड्रॉप के साथ जैसा मिलता है, वैसा ही अच्छा परिणाम मिलता है