pandas 0.23 - DataFrame.replace()

pandas.DataFrame.replace




pandas

pandas.DataFrame.replace

DataFrame.replace(to_replace=None, value=None, inplace=False, limit=None, regex=False, method='pad') [source]

मान के साथ to_replace में दिए गए मान बदलें।

DataFrame के मानों को अन्य मानों के साथ गतिशील रूप से प्रतिस्थापित किया जाता है। यह .loc या .iloc साथ अद्यतन करने से अलग है, जिसके लिए आपको कुछ मान के साथ अद्यतन करने के लिए स्थान निर्दिष्ट करने की आवश्यकता होती है।

पैरामीटर:

to_replace : str, regex, list, dict, Series, int, float, या कोई नहीं

उन मूल्यों को कैसे खोजना है जिन्हें प्रतिस्थापित किया जाएगा।

  • संख्यात्मक, str या regex:

    • संख्यात्मक: to_replace बराबर संख्यात्मक मान को value साथ बदल दिया जाएगा
    • str: स्ट्रिंग बिलकुल मैचिंग to_replace को value बदला जाएगा
    • regex: to_replace से मेल खाते to_replace को value बदला जाएगा
  • str, regex, या संख्यात्मक की सूची:

    • सबसे पहले, अगर to_replace और value दोनों to_replace , तो to_replace लंबाई समान होनी चाहिए।
    • दूसरा, यदि regex=True तो दोनों सूचियों के सभी स्ट्रिंग्स को रेग्क्स के रूप में व्याख्या किया जाएगा अन्यथा वे सीधे मेल करेंगे। यह value लिए बहुत मायने नहीं रखता है क्योंकि केवल कुछ संभावित प्रतिस्थापन रीगेक्स हैं जो आप उपयोग कर सकते हैं।
    • उपरोक्त के रूप में str, regex और संख्यात्मक नियम लागू होते हैं।
  • dict:

    • विभिन्न मौजूदा मूल्यों के लिए अलग-अलग प्रतिस्थापन मूल्यों को निर्दिष्ट करने के लिए डायट्स का उपयोग किया जा सकता है। उदाहरण के लिए, {'a': 'b', 'y': 'z'} 'a' को 'b' और 'y' को 'z' के साथ बदल देता है। इस तरह से एक तानाशाह का उपयोग करने के लिए value पैरामीटर None होना चाहिए।
    • एक DataFrame के लिए एक तानाशाह निर्दिष्ट कर सकता है कि अलग-अलग कॉलम में अलग-अलग मान बदले जाने चाहिए। उदाहरण के लिए, {'a': 1, 'b': 'z'} कॉलम 'a' में मान 1 और स्तंभ {'a': 1, 'b': 'z'} का मूल्य खोजता है और इन मानों को value में निर्दिष्ट की गई चीजों से बदल देता है। value पैरामीटर इस मामले में None नहीं होना चाहिए। आप इसे दो सूचियों को पारित करने के एक विशेष मामले के रूप में मान सकते हैं, सिवाय इसके कि आप कॉलम को खोजने के लिए निर्दिष्ट कर रहे हैं।
    • एक DataFrame नेस्टेड शब्दकोशों के लिए, उदाहरण के लिए, {'a': {'b': np.nan}} , निम्नानुसार पढ़े जाते हैं: स्तंभ 'a' में 'value' b 'देखें और इसे NaN से बदलें। इस तरह से नेस्टेड तानाशाह का उपयोग करने के लिए value पैरामीटर None होना चाहिए। आप नियमित रूप से भी अभिव्यक्ति कर सकते हैं। ध्यान दें कि स्तंभ नाम (किसी नेस्टेड शब्दकोश में शीर्ष-स्तरीय शब्दकोश कुंजियाँ) नियमित अभिव्यक्ति नहीं हो सकते हैं
  • कोई नहीं:

    • इसका मतलब यह है कि regex तर्क में एक स्ट्रिंग, संकलित नियमित अभिव्यक्ति, या सूची, तानाशाही, ndarray या ऐसे तत्वों की श्रृंखला होनी चाहिए। यदि value भी None तो यह एक नेस्टेड शब्दकोश या श्रृंखला होनी चाहिए।

इनमें से प्रत्येक के उदाहरण के लिए उदाहरण अनुभाग देखें।

मूल्य : स्केलर, तानाशाह, सूची, str, regex, डिफ़ॉल्ट कोई नहीं

मान को किसी भी मान से बदलने के लिए। एक DataFrame के लिए मानों का एक ताना-बाना निर्दिष्ट किया जा सकता है कि प्रत्येक कॉलम के लिए किस मूल्य का उपयोग किया जाए (जो कि तानाशाह में नहीं भरे गए हैं)। ऐसी वस्तुओं की नियमित अभिव्यक्तियों, तार और सूचियों या डिकेट की भी अनुमति है।

निष्क्रिय : बूलियन, डिफ़ॉल्ट गलत

अगर सच है, जगह में। नोट: यह इस ऑब्जेक्ट पर किसी भी अन्य विचार को संशोधित करेगा (जैसे एक DataFrame से एक स्तंभ)। यह सही है, तो कॉलर लौटाता है।

सीमा : int, डिफ़ॉल्ट कोई नहीं

आगे या पीछे भरने के लिए अधिकतम आकार का अंतर।

regex : bool या उसी प्रकार to_replace , डिफ़ॉल्ट गलत

नियमित अभिव्यक्ति के रूप में to_replace और / या value व्याख्या to_replace या नहीं। यदि यह True तो to_replace एक स्ट्रिंग होना चाहिए। वैकल्पिक रूप से, यह एक नियमित अभिव्यक्ति हो सकती है या नियमित अभिव्यक्तियों की एक सूची, तानाशाही, या सरणी हो सकती है जिस स्थिति में to_replace None होना चाहिए।

विधि : {'पैड', 'एफफिल', 'बाइफिल', None }

प्रतिस्थापन के लिए उपयोग करने की विधि, जब to_replace एक अदिश, सूची या टपल है और value None

संस्करण में परिवर्तित किया गया 0.23.0: डेटाफ्रेम में जोड़ा गया।

यह दिखाता है:

डेटा ढांचा

प्रतिस्थापन के बाद वस्तु।

जन्म देती है:

AssertionError

  • यदि regex एक bool नहीं है और to_replace कोई None

त्रुटि प्रकार

  • यदि to_replace एक to_replace है और value एक list , to_replace , to_replace , या Series
  • यदि to_replace None और regex एक नियमित अभिव्यक्ति में to_replace None है या एक सूची, तानाशाही, ndarray, या श्रृंखला है।
  • एकाधिक bool या to_replace ऑब्जेक्ट्स को प्रतिस्थापित करते datetime64 और to_replace के तर्क प्रतिस्थापित किए जा रहे मूल्य के प्रकार से मेल नहीं खाते

ValueError

  • यदि एक list या एक to_replace और value पर पारित किया to_replace लेकिन वे समान लंबाई नहीं हैं।

यह भी देखें

DataFrame.fillna
एनए मान भरें
DataFrame.where
बूलियन स्थिति के आधार पर मूल्यों को बदलें
Series.str.replace
सरल स्ट्रिंग प्रतिस्थापन।

टिप्पणियाँ

  • रेगेक्स प्रतिस्थापन हूड के साथ re.sub तहत किया जाता है। re.sub लिए प्रतिस्थापन के नियम समान हैं।
  • नियमित अभिव्यक्ति केवल स्ट्रिंग पर स्थानापन्न होगी, जिसका अर्थ है कि आप प्रदान नहीं कर सकते हैं, उदाहरण के लिए, एक नियमित अभिव्यक्ति फ्लोटिंग पॉइंट संख्याओं से मेल खाती है और आपके फ्रेम में उन स्तंभों की अपेक्षा करता है जिनके पास एक संख्यात्मक dtype मेल खाता है। हालांकि, यदि वे फ़्लोटिंग पॉइंट नंबर स्ट्रिंग हैं, तो आप ऐसा कर सकते हैं।
  • इस विधि में बहुत सारे विकल्प हैं। आपको इस पद्धति के साथ प्रयोग करने और खेलने के लिए प्रोत्साहित किया जाता है कि यह कैसे काम करता है।
  • जब to_replace को to_replace मान के रूप में उपयोग किया जाता है, तो यह key (s) की तरह होता है, तानाशाह में to_replace हिस्सा होता है और dict में value (s) मान पैरामीटर होता है।

उदाहरण

स्केलर `to_replace` और` value`

>>> s = pd.Series([0, 1, 2, 3, 4])
>>> s.replace(0, 5)
0    5
1    1
2    2
3    3
4    4
dtype: int64
>>> df = pd.DataFrame({'A': [0, 1, 2, 3, 4],
...                    'B': [5, 6, 7, 8, 9],
...                    'C': ['a', 'b', 'c', 'd', 'e']})
>>> df.replace(0, 5)
   A  B  C
0  5  5  a
1  1  6  b
2  2  7  c
3  3  8  d
4  4  9  e

सूची-जैसे `to_replace`

>>> df.replace([0, 1, 2, 3], 4)
   A  B  C
0  4  5  a
1  4  6  b
2  4  7  c
3  4  8  d
4  4  9  e
>>> df.replace([0, 1, 2, 3], [4, 3, 2, 1])
   A  B  C
0  4  5  a
1  3  6  b
2  2  7  c
3  1  8  d
4  4  9  e
>>> s.replace([1, 2], method='bfill')
0    0
1    3
2    3
3    3
4    4
dtype: int64

तानाशाह की तरह `to_replace`

>>> df.replace({0: 10, 1: 100})
     A  B  C
0   10  5  a
1  100  6  b
2    2  7  c
3    3  8  d
4    4  9  e
>>> df.replace({'A': 0, 'B': 5}, 100)
     A    B  C
0  100  100  a
1    1    6  b
2    2    7  c
3    3    8  d
4    4    9  e
>>> df.replace({'A': {0: 100, 4: 400}})
     A  B  C
0  100  5  a
1    1  6  b
2    2  7  c
3    3  8  d
4  400  9  e

नियमित अभिव्यक्ति `to_replace`

>>> df = pd.DataFrame({'A': ['bat', 'foo', 'bait'],
...                    'B': ['abc', 'bar', 'xyz']})
>>> df.replace(to_replace=r'^ba.$', value='new', regex=True)
      A    B
0   new  abc
1   foo  new
2  bait  xyz
>>> df.replace({'A': r'^ba.$'}, {'A': 'new'}, regex=True)
      A    B
0   new  abc
1   foo  bar
2  bait  xyz
>>> df.replace(regex=r'^ba.$', value='new')
      A    B
0   new  abc
1   foo  new
2  bait  xyz
>>> df.replace(regex={r'^ba.$':'new', 'foo':'xyz'})
      A    B
0   new  abc
1   xyz  new
2  bait  xyz
>>> df.replace(regex=[r'^ba.$', 'foo'], value='new')
      A    B
0   new  abc
1   new  new
2  bait  xyz

ध्यान दें कि कई bool या to_replace ऑब्जेक्ट्स को प्रतिस्थापित करते datetime64 , to_replace पैरामीटर के डेटा प्रकारों को प्रतिस्थापित किए जा रहे मूल्य के डेटा प्रकार से मेल खाना चाहिए:

>>> df = pd.DataFrame({'A': [True, False, True],
...                    'B': [False, True, False]})
>>> df.replace({'a string': 'new value', True: False})  # raises
Traceback (most recent call last):
    ...
TypeError: Cannot compare types 'ndarray(dtype=bool)' and 'str'

यह एक TypeError बढ़ाता है क्योंकि dict चाबियों में से एक प्रतिस्थापन के लिए सही प्रकार की नहीं है।

to_replace पैरामीटर की to_replace को समझने के लिए s.replace s.replace({'a': None}) s.replace('a', None) s.replace({'a': None}) और s.replace('a', None) s.replace({'a': None}) के व्यवहार की तुलना करें:

>>> s = pd.Series([10, 'a', 'a', 'b', 'a'])

जब कोई to_replace को to_replace वैल्यू के रूप में to_replace करता है, तो यह उस तरह होता है जैसे कि dict में वैल्यू (मान) पैरामीटर के बराबर होता है। s.replace({'a': None}) s.replace(to_replace={'a': None}, value=None, method=None) s.replace({'a': None}) s.replace(to_replace={'a': None}, value=None, method=None) s.replace({'a': None}) के बराबर है:

>>> s.replace({'a': None})
0      10
1    None
2    None
3       b
4    None
dtype: object

जब value=None और to_replace एक स्केलर, सूची या टपल है, तो replace लिए विधि पैरामीटर (डिफ़ॉल्ट 'पैड') का उपयोग करता है। इसलिए यही कारण है कि इस मामले में 'ए' मानों को पंक्तियों 1 और 2 में 10 और पंक्ति 4 में 'बी' द्वारा प्रतिस्थापित किया जा रहा है। कमांड s.replace('a', None) वास्तव में s.replace(to_replace='a', value=None, method='pad') बराबर है:

>>> s.replace('a', None)
0    10
1    10
2    10
3     b
4     b
dtype: object