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

Python dask.dataframe.Series.replace用法及代碼示例


用法:

Series.replace(to_replace=None, value=None, regex=False)

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

此文檔字符串是從 pandas.core.frame.DataFrame.replace 複製而來的。

可能存在與 Dask 版本的一些不一致之處。

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

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

參數：

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

如何找到將被替換的值。

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

    • numeric：等於to_replace的數值將替換為value

    • str：與to_replace完全匹配的字符串將被替換為value

    • 正則表達式：匹配 to_replace 的正則表達式將替換為 value

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

    • 首先，如果to_replace和value都是列表，它們必須長度相同。

    • 其次，如果regex=True然後所有的字符串兩個都列表將被解釋為正則表達式，否則它們將直接匹配。這無關緊要value因為隻有幾個可能的替換正則表達式可以使用。

    • str、regex 和 numeric 規則如上適用。

  • 字典：

    • 字典可用於為不同的現有值指定不同的替換值。例如，{'a': 'b', 'y': 'z'} 將值 ‘a’ 替換為 ‘b’ and ‘y’ 和 ‘z’。要以這種方式使用字典，value 參數應該是 None 。

    • 對於 DataFrame，dict 可以指定應在不同列中替換不同的值。例如，{'a': 1, 'b': 'z'} 在 ‘a’ 列中查找值 1，在 ‘b’ 列中查找值 ‘z’，並將這些值替換為 value 中指定的值。在這種情況下，value 參數不應為 None。您可以將此視為傳遞兩個列表的特殊情況，除非您指定要搜索的列。

    • 對於 DataFrame 嵌套字典，例如，{'a': {'b': np.nan}}, 讀取如下：在列 ‘a’ 中查找值 ‘b’ 並將其替換為 NaN。這value參數應該是None以這種方式使用嵌套字典。您也可以嵌套正則表達式。請注意列名(嵌套字典中的頂級字典鍵)不能是正則表達式。

  • None:

    • 這意味著regex參數必須是字符串、編譯的正則表達式或列表、字典、ndarray 或此類元素的係列。如果value也是None那麽這個必須是嵌套字典或係列。

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

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

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

inplace：bool，默認 False(在 Dask 中不支持)

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

limit：int，默認無(在 Dask 中不支持)

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

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

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

method：{‘pad’, ‘ffill’, ‘bfill’, None }(Dask 不支持)

當 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

相關用法


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