में pandasपुस्तकालय में कई बार के निम्नलिखित बयान के साथ के रूप में ऐसी inplace वस्तु को बदलने के लिए एक विकल्प है ...
df.dropna(axis='index', how='all', inplace=True)
मैं उत्सुक हूं कि क्या दिया जा रहा है और साथ ही वस्तु को कैसे संभाला जाता है जब inplace=Trueबनाम पास किया जाता है inplace=False।
क्या सभी ऑपरेशन selfकब संशोधित होते हैं inplace=True? और जब inplace=Falseकोई नया ऑब्जेक्ट तुरंत बनाया जाता है जैसे कि new_df = selfऔर फिर new_dfवापस किया जाता है?
self = self.merge(new_df, how='left', on='column2' मुझे यकीन नहीं है कि आत्म
inplaceतर्क नहीं है। यह एक DataFrame लौटाता है, इसलिए कोई समस्या नहीं है।
inplaceकार्रवाई थोड़ी तेज़ हो सकती है क्योंकि आपको वास्तव में परिणाम की एक प्रति वापस नहीं करनी है। इसके बारे में बस इतना ही। इसे इस्तेमाल न करने के और भी कारण हैं।
जवाबों:
जब पास हो inplace=Trueजाता है, तो डेटा का नाम बदल दिया जाता है (यह कुछ भी नहीं देता है), इसलिए आप उपयोग करेंगे:
df.an_operation(inplace=True)
जब पास किया inplace=Falseजाता है (यह डिफ़ॉल्ट मान है, तो यह आवश्यक नहीं है), ऑपरेशन करता है और ऑब्जेक्ट की एक प्रति लौटाता है, इसलिए आप उपयोग करेंगे:
df = df.an_operation(inplace=False)
inplaceमौजूदा तरीकों में बदलाव के लिए केवल एक विकल्प है, लेकिन उन तरीकों के लिए नहीं जो डेटा को 'फेरबदल' करते हैं। उदाहरण के लिए, मैं .set_index (inplace = True) कर सकता हूं क्योंकि यह मौजूदा इंडेक्स में मानों को लागू करता है, लेकिन .reindex (inplace = True) को लागू कर सकता है क्योंकि इससे DataFrame पर अतिरिक्त पंक्तियां बन सकती हैं जो पिछले एरे में मौजूद नहीं थीं। ?
.dropna()स्वीकार करती है inplace=Trueऔर निश्चित रूप से डेटाफ्रेम को फिर से खोल सकती है, इसलिए नहीं।
dropnaविभिन्न आकार की एक डेटाफ्रेम लौटाते समय , यह वास्तव में अंतर्निहित डेटा को फिर से खोलना नहीं करता है - यह केवल उस पर (जब inplace=False) एक मुखौटा देता है , जो खतरनाक हो सकता है SettingWithCopyWarning। केवल तब जब मानों की पुरानी सरणी के संदर्भ में कोई और संदर्भ न हो, मास्क के अनुसार पांडा फिर से चलेंगे। अंगूठे का एक बेहतर नियम है: inplaceयह तब उपलब्ध होता है जब ऑपरेशन को मानों के एक नए बैकिंग ndarray को आवंटित करने की आवश्यकता नहीं होती है।
inplace, इसके विपरीत जो नाम का अर्थ है, अक्सर प्रतियों को बनाए जाने से नहीं रोकता है, और (लगभग) कभी भी कोई प्रदर्शन लाभ प्रदान नहीं करता हैinplace विधि जंजीर के साथ काम नहीं करता हैinplace शुरुआती लोगों के लिए एक सामान्य नुकसान है, इसलिए इस विकल्प को हटाने से एपीआई सरल हो जाएगामैं इस पैरामीटर को सेट करने की सलाह नहीं देता क्योंकि यह थोड़ा उद्देश्य प्रदान करता है । इस GitHub मुद्दे को देखें जो inplaceतर्क का प्रस्ताव करता है को अप्रीकृत चौड़ा किया जाए।
यह एक सामान्य गलत धारणा है कि उपयोग inplace=Trueकरने से अधिक कुशल या अनुकूलित कोड प्राप्त होगा। वास्तव में, उपयोग करने के लिए बिल्कुल कोई प्रदर्शन लाभ नहीं हैं inplace=True। इन-प्लेस और आउट-ऑफ-प्लेस दोनों संस्करण डेटा की एक प्रति वैसे भी बनाते हैं , इन-प्लेस संस्करण स्वचालित रूप से कॉपी बैक असाइन करते हैं।
inplace=Trueशुरुआती लोगों के लिए एक आम नुकसान है। उदाहरण के लिए, यह ट्रिगरSettingWithCopyWarning कर सकता है :
df = pd.DataFrame({'a': [3, 2, 1], 'b': ['x', 'y', 'z']})
df2 = df[df['a'] > 1]
df2['b'].replace({'x': 'abc'}, inplace=True)
# SettingWithCopyWarning:
# A value is trying to be set on a copy of a slice from a DataFrame
किसी काम के साथ inplace=True या नहीं हो सकता है के साथ एक DataFrame स्तंभ पर एक फ़ंक्शन कॉल करना । यह विशेष रूप से सच है जब जंजीर अनुक्रमण शामिल है।
जैसे कि ऊपर वर्णित समस्याएँ पर्याप्त नहीं हैं, inplace=Trueयह भी विधि का अड़चन है । के विपरीत काम करते हैं
result = df.some_function1().reset_index().some_function2()
विरोध के रूप में
temp = df.some_function1()
temp.reset_index(inplace=True)
result = temp.some_function2()
पूर्व बेहतर कोड संगठन और पठनीयता के लिए उधार देता है।
एक अन्य सहायक दावा यह है कि एपीआई के लिए set_axisहाल ही में ऐसा परिवर्तन किया गया था कि inplaceडिफ़ॉल्ट मान को ट्रू से गलत पर स्विच किया गया था। GH27600 देखें । महान नौकरी देवों!
inplace=Trueहै कि अस्तर के साथ काम नहीं करता है, लेकिन यह स्पष्ट है कि आप समझ रहे हैं कि यह वैचारिक रूप से क्या कर रहा है। व्यक्तिगत रूप से मुझे असाइनमेंट से बचने के लिए यह थोड़ा साफ लगता है- क्या आप list.sortमानक लाइब्रेरी से हटाने आदि के पक्ष में होंगे ?
list.append()भी इन-प्लेस है, जबकि पांडा df.append नहीं है (और यह भी inplace का समर्थन नहीं करता है), जो मुझे किसी भी अंत में परेशान नहीं करता है। यही कारण है कि मैं जानना चाहता हूं, बस यह समझने के लिए कि वास्तविक लाभ क्या हैं - असाइनमेंट से बचने के अलावा, लिस्ट। सॉर्ट बनाम सॉर्ट किए गए उपयोग करने के स्पष्ट लाभ क्या हैं? अन्यथा, मुझे लगता है कि यहां वास्तविक लाभ है - मुझे असाइनमेंट से बचने में सक्षम होना चाहिए, जहां मैं व्यक्तिगत रूप से इसे अधिक पठनीय पाता हूं।
list.append()मौजूदा सूची में संलग्न है। df.appendआपके डेटा की एक प्रतिलिपि बनाता है (आपके लिए 5 पंक्तियों या 5 मिलियन का कोई फर्क नहीं पड़ता), फिर अपनी प्रति में एक नई पंक्ति जोड़ता है, फिर उसे वापस करता है। आपको क्या लगता है कि अधिक समझ में आता है? Df.append, AVOID AS MUCH AS POSSIBLE के रूप में । मुझे नहीं लगता कि यह inplace = true के लिए बहस करने के लिए एक अच्छा उदाहरण है, मुझे नहीं लगता है कि फ़ंक्शन का एपीआई में कोई स्थान है।
जिस तरह से मैं इसका उपयोग करता हूं
# Have to assign back to dataframe (because it is a new copy)
df = df.some_operation(inplace=False)
या
# No need to assign back to dataframe (because it is on the same copy)
df.some_operation(inplace=True)
निष्कर्ष:
if inplace is False
Assign to a new variable;
else
No need to assign
inplaceपैरामीटर:
df.dropna(axis='index', how='all', inplace=True)
में Pandasऔर सामान्य साधन में:
1. पंडों मूल डेटा की एक प्रति बनाता है
2. “इस पर कुछ गणना करता है
3. " मूल डेटा को परिणाम प्रदान करता है।
4. " कॉपी को हटाता है।
जैसा कि आप मेरे उत्तर के बाकी हिस्सों में नीचे पढ़ सकते हैं, फिर भी हमारे पास इस पैरामीटर का उपयोग करने का अच्छा कारण हो सकता है inplace operations, लेकिन हमें इससे बचना चाहिए, क्योंकि हम कर सकते हैं, क्योंकि यह अधिक मुद्दों को उत्पन्न करता है, जैसे:
1. आपका कोड डिबग करने के लिए कठिन होगा (वास्तव में SettingwithCopyWarning इस संभावित समस्या के लिए आपको चेतावनी देने के लिए खड़ा है)
2. विधि जंजीर के साथ संघर्ष
निश्चित रूप से हाँ। यदि हम विशाल डेटासेट को हैंडल करने के लिए पांडा या किसी भी उपकरण का उपयोग करते हैं, तो हम आसानी से उस स्थिति का सामना कर सकते हैं, जहां कुछ बड़े डेटा हमारी संपूर्ण मेमोरी का उपभोग कर सकते हैं। इस अवांछित प्रभाव हम जैसे कुछ शब्दावली का उपयोग कर सकते हैं से बचने के लिए विधि श्रृंखलन :
(
wine.rename(columns={"color_intensity": "ci"})
.assign(color_filter=lambda x: np.where((x.hue > 1) & (x.ci > 7), 1, 0))
.query("alcohol > 14 and color_filter == 1")
.sort_values("alcohol", ascending=False)
.reset_index(drop=True)
.loc[:, ["alcohol", "ci", "hue"]]
)
जो हमारे कोड को और अधिक कॉम्पैक्ट बनाते हैं (हालांकि व्याख्या और डीबग करना भी कठिन है) और कम मेमोरी का उपभोग करता है क्योंकि अन्य विधियों के लौटे मानों के साथ जंजीर विधियां काम करती हैं, जिसके परिणामस्वरूप इनपुट डेटा की केवल एक प्रति प्राप्त होती है। हम स्पष्ट रूप से देख सकते हैं, कि इस ऑपरेशन के बाद हमारे पास 2 x मूल डेटा मेमोरी की खपत होगी।
या हम inplaceपैरामीटर का उपयोग कर सकते हैं (हालांकि व्याख्या करना और डीबग करना भी कठिन है) हमारी मेमोरी की खपत 2 x मूल डेटा होगी , लेकिन इस ऑपरेशन के बाद हमारी मेमोरी की खपत 1 एक्स मूल डेटा बनी हुई है , जो कि जब भी कोई व्यक्ति विशाल डेटासेट के साथ काम करता है , तो वह वास्तव में जानता हो सकता है बड़ा फायदा।
inplaceपैरामीटर का उपयोग करने से बचें जब तक कि आप विशाल डेटा के साथ काम न करें और इसके उपयोग के मामले में इसके संभावित मुद्दों से अवगत रहें ।
इसे उसी वेरिएबल में सेव करें
data["column01"].where(data["column01"]< 5, inplace=True)
इसे एक अलग चर में सहेजें
data["column02"] = data["column01"].where(data["column1"]< 5)
लेकिन, आप हमेशा चर को अधिलेखित कर सकते हैं
data["column01"] = data["column01"].where(data["column1"]< 5)
FYI करें: डिफ़ॉल्ट रूप से inplace = False
जब एक फ़ंक्शन का उपयोग करके पंडों के डेटाफ़्रेम में परिवर्तन करने की कोशिश की जाती है, तो हम 'inplace = True' का उपयोग करते हैं यदि हम डेटाफ़्रेम में परिवर्तन करना चाहते हैं। इसलिए, निम्न कोड में पहली पंक्ति 'df' में 'कॉलम' के पहले कॉलम का नाम बदल देती है। यदि हम परिणामी डेटाबेस को देखना चाहते हैं तो हमें डेटाबेस को कॉल करना होगा।
df.rename(columns={0: 'Grades'}, inplace=True)
df
जब हम परिवर्तन नहीं करना चाहते, लेकिन परिणामी डेटाबेस को प्रिंट नहीं करना चाहते, तो हम 'inplace = गलत' (यह भी डिफ़ॉल्ट मान है) का उपयोग करते हैं। इसलिए, मूल डेटाबेस में परिवर्तन किए बिना प्रतिबद्ध परिवर्तनों के साथ मूल डेटाबेस की एक प्रति प्रभावी रूप से मुद्रित की जाती है।
बस अधिक स्पष्ट होने के लिए, निम्नलिखित कोड समान कार्य करते हैं:
#Code 1
df.rename(columns={0: 'Grades'}, inplace=True)
#Code 2
df=df.rename(columns={0: 'Grades'}, inplace=False}
inplace=True यदि आप मूल df में परिवर्तन करना चाहते हैं या नहीं, इसके आधार पर उपयोग किया जाता है।
df.drop_duplicates()
केवल गिराए गए मूल्यों का एक दृश्य बनाएगा लेकिन df में कोई बदलाव नहीं करेगा
df.drop_duplicates(inplace = True)
मान गिराएंगे और df में परिवर्तन करेंगे।
उम्मीद है की यह मदद करेगा।:)
inplace=Trueफ़ंक्शन को अशुद्ध बनाता है। यह मूल डेटाफ़्रेम बदलता है और कोई नहीं लौटाता है। उस स्थिति में, आप DSL श्रृंखला को तोड़ते हैं। क्योंकि अधिकांश डेटाफ़्रेम फ़ंक्शंस एक नया डेटाफ़्रेम लौटाते हैं, आप DSL को आसानी से उपयोग कर सकते हैं। पसंद
df.sort_values().rename().to_csv()
inplace=Trueरिटर्न कॉल के साथ फंक्शन कॉल और डीएसएल चेन टूटी हुई है। उदाहरण के लिए
df.sort_values(inplace=True).rename().to_csv()
फेंक देंगे NoneType object has no attribute 'rename'
अजगर के बिल्ड-इन सॉर्ट और सॉर्ट के साथ कुछ ऐसा ही है। lst.sort()रिटर्न Noneऔर sorted(lst)रिटर्न एक नई सूची।
आम तौर पर, inplace=Trueजब तक आपके पास ऐसा करने का विशिष्ट कारण न हो, तब तक उपयोग न करें। जब आपको पुनर्मूल्यांकन कोड लिखना होगा df = df.sort_values(), जैसे कि DSL श्रृंखला में फ़ंक्शन कॉल संलग्न करने का प्रयास करें, जैसे
df = pd.read_csv().sort_values()...
जैसा कि पंडों में मेरा अनुभव मुझे उत्तर देना चाहता है।
डेटा फ्रेम के लिए 'inplace = true' तर्क का अर्थ परिवर्तन को स्थायी बनाना है।
df.dropna(axis='index', how='all', inplace=True)
उसी डेटाफ्रेम को बदल देता है (जैसा कि यह पांडा सूचकांक में NaN प्रविष्टियां पाता है और उन्हें छोड़ देता है)। अगर हम कोशिश करें
df.dropna(axis='index', how='all')
पांडा हमारे द्वारा किए गए परिवर्तनों के साथ डेटाफ़्रेम दिखाता है लेकिन मूल डेटाफ़्रेम 'df' को संशोधित नहीं करेगा।
यदि आप inplace = true का उपयोग नहीं करते हैं या आप inplace का उपयोग करते हैं = गलत तरीके से आप मूल रूप से एक प्रति वापस प्राप्त करते हैं।
उदाहरण के लिए:
testdf.sort_values(inplace=True, by='volume', ascending=False)
अवरोही क्रम में छाँटे गए डेटा के साथ संरचना को बदल देगा।
फिर:
testdf2 = testdf.sort_values( by='volume', ascending=True)
testdf2 को कॉपी बना देगा। मान सभी समान होंगे लेकिन क्रम उलट जाएगा और आपके पास एक स्वतंत्र वस्तु होगी।
फिर एक और कॉलम दिया गया, लोंग्मा का कहना है और आप करते हैं:
testdf2.LongMA = testdf2.LongMA -1
Testdf में LongMA कॉलम में मूल मान होंगे और testdf2 में डिक्रिमेंट वैल्यूज़ होंगे।
अंतर का ट्रैक रखना महत्वपूर्ण है क्योंकि गणना की श्रृंखला बढ़ती है और डेटाफ्रेम की प्रतियों का अपना जीवनचक्र होता है।
हां, पंडों में हमारे कई कार्य हैं, inplaceलेकिन पैरामीटर डिफ़ॉल्ट रूप से इसे सौंपा गया है False।
इसलिए, जब आप ऐसा df.dropna(axis='index', how='all', inplace=False)सोचते हैं कि आप ऑरिजिनल को बदलना नहीं चाहते हैं DataFrame, इसलिए यह आवश्यक बदलावों के साथ आपके लिए एक नई प्रति बनाता है ।
लेकिन, जब आप inplaceपैरामीटर को बदलते हैंTrue
तब यह स्पष्ट रूप से कहने के बराबर है कि मैं
DataFrameइसके बदले नई प्रति नहीं चाहताDataFrame
यह पायथन दुभाषिया को एक नया निर्माण नहीं करने के लिए मजबूर करता हैDataFrame
लेकिन आप inplaceपरिणाम को Orignal DataFrame पर पुन: असाइन करके पैरामीटर का उपयोग करने से भी बच सकते हैं
df = df.dropna(axis='index', how='all')
inplace=TrueलौटाएNoneinplace=Falseगए ऑब्जेक्ट की एक प्रति रिटर्न किए गए ऑपरेशन के साथ। डॉक्स इस पर बहुत स्पष्ट हैं, क्या कुछ ऐसा है जो एक विशिष्ट भाग के साथ भ्रमित है? SpeficallyIf True, do operation inplace and return None.