pandas.Series.str.replace#

Series.str.replace(pat, repl=None, n=-1, case=None, flags=0, regex=False)[源代码]#

替换 Series/Index 中每个 pattern/regex 的出现。

相当于 str.replace() 或 re.sub()，取决于 regex 值。

参数:
pat字符串、编译的正则表达式或字典

字符串可以是字符序列或正则表达式。字典包含 <键 : 值> 对，表示要替换的字符串及其更新值。

replstr 或 可调用对象

替换字符串或可调用对象。可调用对象会传递正则表达式匹配对象，并必须返回一个替换字符串。如果 pat 是字典，则必须为 None。请参见 re.sub()。

nint, 默认 -1 (所有)

从开始进行替换的数量。

案例布尔值, 默认为 None

确定替换是否区分大小写：

  • 如果为真，区分大小写（如果 pat 是字符串，则为默认值）

  • 设置为 False 以进行不区分大小写的匹配

  • 如果 pat 是一个已编译的正则表达式，则不能设置。

标志int, 默认 0 (无标志)

正则表达式模块标志，例如 re.IGNORECASE。如果 pat 是一个已编译的正则表达式，则不能设置。

正则表达式布尔值, 默认为 False

确定传入的模式是否为正则表达式：

  • 如果为真，则假设传入的模式是正则表达式。

  • 如果为 False，则将模式视为字面字符串

  • 如果 pat 是一个已编译的正则表达式或 repl 是一个可调用对象，则不能设置为 False。

返回:
对象的系列或索引

一个对象的副本，其中所有匹配 pat 的出现都被 repl 替换。

引发:
ValueError

  • 如果 regex 是 False 并且 repl 是一个可调用对象或 pat 是一个已编译的正则表达式

  • 如果 pat 是一个已编译的正则表达式，并且设置了 case 或 flags

  • 如果 pat 是一个字典且 repl 不为 None。

参见

Series.str.replace

Method to replace occurrences of a substring with another substring.

Series.str.extract

Extract substrings using a regular expression.

Series.str.findall

Find all occurrences of a pattern or regex in each string.

Series.str.split

Split each string by a specified delimiter or pattern.

备注

当 pat 是一个已编译的正则表达式时，所有标志应包含在已编译的正则表达式中。使用 case、flags 或 regex=False 与已编译的正则表达式将引发错误。

例子

当 pat 是一个字典时，pat 中的每个键都会被其对应的值替换：

>>> pd.Series(["A", "B", np.nan]).str.replace(pat={"A": "a", "B": "b"})
0    a
1    b
2    NaN
dtype: object

当 pat 是一个字符串且 regex 为 True 时，给定的 pat 被编译为正则表达式。当 repl 是一个字符串时，它替换匹配的正则表达式模式，如同使用 re.sub()。Series 中的 NaN 值保持不变：

>>> pd.Series(["foo", "fuz", np.nan]).str.replace("f.", "ba", regex=True)
0    bao
1    baz
2    NaN
dtype: object

当 pat 是一个字符串且 regex 为 False 时，每个 pat 都会被 repl 替换，如同 str.replace() 那样：

>>> pd.Series(["f.o", "fuz", np.nan]).str.replace("f.", "ba", regex=False)
0    bao
1    fuz
2    NaN
dtype: object

当 repl 是一个可调用对象时，它会在每个 pat 上调用 re.sub()。该可调用对象应接受一个位置参数（一个正则表达式对象）并返回一个字符串。

要理解这个概念：

>>> pd.Series(["foo", "fuz", np.nan]).str.replace("f", repr, regex=True)
0    <re.Match object; span=(0, 1), match='f'>oo
1    <re.Match object; span=(0, 1), match='f'>uz
2                                            NaN
dtype: object

反转每个小写字母单词：

>>> repl = lambda m: m.group(0)[::-1]
>>> ser = pd.Series(["foo 123", "bar baz", np.nan])
>>> ser.str.replace(r"[a-z]+", repl, regex=True)
0    oof 123
1    rab zab
2        NaN
dtype: object

使用正则表达式组（提取第二组并交换大小写）：

>>> pat = r"(?P<one>\w+) (?P<two>\w+) (?P<three>\w+)"
>>> repl = lambda m: m.group("two").swapcase()
>>> ser = pd.Series(["One Two Three", "Foo Bar Baz"])
>>> ser.str.replace(pat, repl, regex=True)
0    tWO
1    bAR
dtype: object

使用带有标志的编译正则表达式

>>> import re
>>> regex_pat = re.compile(r"FUZ", flags=re.IGNORECASE)
>>> pd.Series(["foo", "fuz", np.nan]).str.replace(regex_pat, "bar", regex=True)
0    foo
1    bar
2    NaN
dtype: object