将 to_replace 中的值替换为 value 。

Series/DataFrame 的值被动态替换为其他值。这与使用 .loc 或 .iloc 进行更新不同，后者需要你指定一个位置来用某个值进行更新。

如何找到将被替换的值。

请参阅示例部分，了解每个示例的示例。

用于替换任何匹配 to_replace 的值。对于 DataFrame，可以使用值的字典来指定每列要使用的值（不在字典中的列将不会被填充）。正则表达式、字符串以及这些对象的列表或字典也是允许的。

如果为真，则就地执行操作并返回 None。

是否将 to_replace 和/或 value 解释为正则表达式。或者，这可以是一个正则表达式或列表、字典或正则表达式数组，在这种情况下 to_replace 必须为 None 。

替换后的对象。

• 如果 regex 不是一个 bool 并且 to_replace 不是 None 。

TypeError

• 如果 to_replace 不是一个标量、类数组、 dict 或 None

• 如果 to_replace 是一个 dict 而 value 不是一个 list 、 dict 、 ndarray 或 Series

• 如果 to_replace 是 None 并且 regex 不能编译成正则表达式或是一个列表、字典、ndarray 或 Series。

• 当替换多个 bool 或 datetime64 对象且 to_replace 的参数与被替换的值的类型不匹配时

ValueError

• 如果将 list 或 ndarray 传递给 to_replace 和 value 但它们的长度不同。

• 正则表达式替换在后台通过 re.sub 执行。 re.sub 的替换规则是相同的。

• 正则表达式只会替换字符串，这意味着你不能提供例如匹配浮点数的正则表达式，并期望数据框中具有数值类型的列会被匹配。然而，如果那些浮点数*是*字符串，那么你可以这样做。

• 这种方法有 很多 选项。鼓励你进行实验并使用这种方法来获得对其工作原理的直观理解。

• 当 dict 用作 to_replace 值时，dict 中的键是 to_replace 部分，dict 中的值是 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
类似列表的 `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
类似字典的 `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):
>>> s.replace({'a': None})
0      10
1    None
2    None
3       b
4    None
dtype: object
如果 None 被显式地传递给 value ，它将被尊重：
>>> s.replace('a', None)
0      10
1    None
2    None
3       b
4    None
dtype: object
当 regex=True 时，value 不是 None 并且 to_replace 是一个字符串，替换将在 DataFrame 的所有列中应用。
>>> df = pd.DataFrame({'A': [0, 1, 2, 3, 4],
...                    'B': ['a', 'b', 'c', 'd', 'e'],
...                    'C': ['f', 'g', 'h', 'i', 'j']})
>>> df.replace(to_replace='^[a-g]', value='e', regex=True)
    A  B  C
0  0  e  e
1  1  e  e
2  2  e  h
3  3  e  i
4  4  e  j
如果 value 不是 None 并且 to_replace 是一个字典，字典的键将是替换将应用的 DataFrame 列。
>>> df.replace(to_replace={'B': '^[a-c]', 'C': '^[h-j]'}, value='e', regex=True)
    A  B  C
0  0  e  f
1  1  e  g
2  2  e  e
3  3  d  e
4  4  e  e