當前位置: 首頁>>代碼示例 >>用法及示例精選 >>正文

Python pandas.DataFrame.replace用法及代碼示例


用法:

DataFrame.replace(to_replace=None, value=NoDefault.no_default, inplace=False, limit=None, regex=False, method=NoDefault.no_default)

將 to_replace 中給出的值替換為 value 。

DataFrame 的值被動態替換為其他值。

這與使用 .loc 或 .iloc 更新不同，後者要求您指定要使用某個值更新的位置。

參數：

to_replace：str、regex、list、dict、Series、int、float 或 None

如何找到將被替換的值。

  • 數字、str 或正則表達式：

    • numeric:numeric values equal to to_replace will be replaced with value

    • str:string exactly matching to_replace will be replaced with value

    • regex:regexs matching to_replace will be replaced with value

  • str、正則表達式或數字的列表：

    • First, if to_replace and value are both lists, they must be the same length.

    • Second, if regex=True then all of the strings in both lists will be interpreted as regexs otherwise they will match directly. This doesn’t matter much for value since there are only a few possible substitution regexes you can use.

    • str, regex and numeric rules apply as above.

  • 字典：

    • Dicts can be used to specify different replacement values for different existing values. For example, {'a':'b', 'y':'z'} replaces the value ‘a’ with ‘b’ and ‘y’ with ‘z’. To use a dict in this way the value parameter should be None.

    • For a DataFrame a dict can specify that different values should be replaced in different columns. For example, {'a':1, 'b':'z'} looks for the value 1 in column ‘a’ and the value ‘z’ in column ‘b’ and replaces these values with whatever is specified in value. The value parameter should not be None in this case. You can treat this as a special case of passing two lists except that you are specifying the column to search in.

    • For a DataFrame nested dictionaries, e.g., {'a':{'b':np.nan}}, are read as follows:look in column ‘a’ for the value ‘b’ and replace it with NaN. The value parameter should be None to use a nested dict in this way. You can nest regular expressions as well. Note that column names (the top-level dictionary keys in a nested dictionary) cannot be regular expressions.

  • None:

    • This means that the regex argument must be a string, compiled regular expression, or list, dict, ndarray or Series of such elements. If value is also None then this must be a nested dictionary or Series.

有關每個示例，請參見示例部分。

value：標量、字典、列表、str、正則表達式、默認無

用於替換與 to_replace 匹配的任何值的值。對於 DataFrame，可以使用值的字典來指定每列使用哪個值(不在字典中的列將不會被填充)。也允許此類對象的正則表達式、字符串和列表或字典。

inplace：布爾值，默認為 False

如果為 True，則就地執行操作並返回 None。

limit：整數，默認無

向前或向後填充的最大尺寸間隙。

regex：

bool 或與 to_replace 相同的類型，默認為 False

是否翻譯to_replace和/或value作為正則表達式。如果這是True然後to_replace 必須成為一個字符串。或者，這可以是一個正則表達式或一個列表、字典或正則表達式數組，在這種情況下to_replace一定是None.

method：

{‘pad’, ‘ffill’, ‘bfill’, None }

當 to_replace 是標量、列表或元組且 value 是 None 時，使用的替換方法。

返回：

DataFrame

替換後的對象。

拋出：

AssertionError

  • 如果 regex 不是 bool 並且 to_replace 不是 None 。

TypeError

  • 如果 to_replace 不是標量，則 array-like、dict 或 None

  • 如果 to_replace 是 dict 並且 value 不是 list 、 dict 、 ndarray 或 Series

  • 如果 to_replace 是 None 並且 regex 不能編譯為正則表達式或者是列表、字典、ndarray 或係列。

  • 當替換多個 bool 或 datetime64 對象並且 to_replace 的參數與被替換值的類型不匹配時

ValueError

  • 如果將 list 或 ndarray 傳遞給 to_replace 和 value 但它們的長度不同。

注意：

  • 使用 re.sub 在後台執行正則表達式替換。 re.sub 的替換規則相同。

  • 正則表達式隻會替換字符串，這意味著您不能提供例如匹配浮點數的正則表達式並期望框架中具有數字 dtype 的列被匹配。但是，如果這些浮點數是字符串，那麽您可以這樣做。

  • 這種方法有很多選擇。我們鼓勵您嘗試和使用這種方法，以直觀地了解它是如何工作的。

  • 當dict用作to_replace值時，就好像dict中的key(s)是to_replace部分，dict中的value(s)是value參數。

例子：

標量`to_replace`和`value`

>>> s = pd.Series([1, 2, 3, 4, 5])
>>> s.replace(1, 5)
0    5
1    2
2    3
3    4
4    5
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

List-like`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    3
1    3
2    3
3    4
4    5
dtype:int64

dict-like`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

比較s.replace({'a':None}) 和s.replace('a', None) 的行為以了解to_replace 參數的特性：

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

當使用字典作為to_replace 值時，就像字典中的值等於value 參數一樣。 s.replace({'a':None}) 等價於 s.replace(to_replace={'a':None}, value=None, method=None) ：

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

當value 未顯式傳遞且to_replace 是標量、列表或元組時，replace 使用方法參數(默認為‘pad’)進行替換。所以這就是為什麽在這種情況下，‘a’ 值在第 1 行和第 2 行中被替換為 10，在第 4 行中被替換為 ‘b’。

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

另一方麵，如果 None 顯式傳遞給 value ，它將被尊重：

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

相關用法


注：本文由純淨天空篩選整理自pandas.pydata.org大神的英文原創作品 pandas.DataFrame.replace。非經特殊聲明，原始代碼版權歸原作者所有，本譯文未經允許或授權，請勿轉載或複製。