diff --git a/pandas/core/strings/accessor.py b/pandas/core/strings/accessor.py index 43df34a7ecbb2..020291f1caf45 100644 --- a/pandas/core/strings/accessor.py +++ b/pandas/core/strings/accessor.py @@ -1348,7 +1348,7 @@ def replace(self, pat, repl, n=-1, case=None, flags=0, regex=None): ) if len(pat) == 1: msg += ( - " In addition, single character regular expressions will" + " In addition, single character regular expressions will " "*not* be treated as literal strings when regex=True." ) warnings.warn(msg, FutureWarning, stacklevel=3) diff --git a/pandas/tests/series/methods/test_replace.py b/pandas/tests/series/methods/test_replace.py index b21a2c54ae615..c32d74c17a47e 100644 --- a/pandas/tests/series/methods/test_replace.py +++ b/pandas/tests/series/methods/test_replace.py @@ -449,14 +449,3 @@ def test_replace_with_compiled_regex(self): result = s.replace({regex: "z"}, regex=True) expected = pd.Series(["z", "b", "c"]) tm.assert_series_equal(result, expected) - - @pytest.mark.parametrize("pattern", ["^.$", "."]) - def test_str_replace_regex_default_raises_warning(self, pattern): - # https://github.com/pandas-dev/pandas/pull/24809 - s = pd.Series(["a", "b", "c"]) - msg = r"The default value of regex will change from True to False" - if len(pattern) == 1: - msg += r".*single character regular expressions.*not.*literal strings" - with tm.assert_produces_warning(FutureWarning) as w: - s.str.replace(pattern, "") - assert re.match(msg, str(w[0].message)) diff --git a/pandas/tests/strings/test_find_replace.py b/pandas/tests/strings/test_find_replace.py index 0815d23f2b493..2104b50c5121a 100644 --- a/pandas/tests/strings/test_find_replace.py +++ b/pandas/tests/strings/test_find_replace.py @@ -10,6 +10,10 @@ _testing as tm, ) +# -------------------------------------------------------------------------------------- +# str.contains +# -------------------------------------------------------------------------------------- + def test_contains(any_string_dtype): values = np.array( @@ -148,6 +152,81 @@ def test_contains_na_kwarg_for_nullable_string_dtype( tm.assert_series_equal(result, expected) +def test_contains_moar(any_string_dtype): + # PR #1179 + s = Series( + ["A", "B", "C", "Aaba", "Baca", "", np.nan, "CABA", "dog", "cat"], + dtype=any_string_dtype, + ) + + result = s.str.contains("a") + expected_dtype = "object" if any_string_dtype == "object" else "boolean" + expected = Series( + [False, False, False, True, True, False, np.nan, False, False, True], + dtype=expected_dtype, + ) + tm.assert_series_equal(result, expected) + + result = s.str.contains("a", case=False) + expected = Series( + [True, False, False, True, True, False, np.nan, True, False, True], + dtype=expected_dtype, + ) + tm.assert_series_equal(result, expected) + + result = s.str.contains("Aa") + expected = Series( + [False, False, False, True, False, False, np.nan, False, False, False], + dtype=expected_dtype, + ) + tm.assert_series_equal(result, expected) + + result = s.str.contains("ba") + expected = Series( + [False, False, False, True, False, False, np.nan, False, False, False], + dtype=expected_dtype, + ) + tm.assert_series_equal(result, expected) + + result = s.str.contains("ba", case=False) + expected = Series( + [False, False, False, True, True, False, np.nan, True, False, False], + dtype=expected_dtype, + ) + tm.assert_series_equal(result, expected) + + +def test_contains_nan(any_string_dtype): + # PR #14171 + s = Series([np.nan, np.nan, np.nan], dtype=any_string_dtype) + + result = s.str.contains("foo", na=False) + expected_dtype = np.bool_ if any_string_dtype == "object" else "boolean" + expected = Series([False, False, False], dtype=expected_dtype) + tm.assert_series_equal(result, expected) + + result = s.str.contains("foo", na=True) + expected = Series([True, True, True], dtype=expected_dtype) + tm.assert_series_equal(result, expected) + + result = s.str.contains("foo", na="foo") + if any_string_dtype == "object": + expected = Series(["foo", "foo", "foo"], dtype=np.object_) + else: + expected = Series([True, True, True], dtype="boolean") + tm.assert_series_equal(result, expected) + + result = s.str.contains("foo") + expected_dtype = "object" if any_string_dtype == "object" else "boolean" + expected = Series([np.nan, np.nan, np.nan], dtype=expected_dtype) + tm.assert_series_equal(result, expected) + + +# -------------------------------------------------------------------------------------- +# str.startswith +# -------------------------------------------------------------------------------------- + + @pytest.mark.parametrize("dtype", [None, "category"]) @pytest.mark.parametrize("null_value", [None, np.nan, pd.NA]) @pytest.mark.parametrize("na", [True, False]) @@ -195,6 +274,11 @@ def test_startswith_nullable_string_dtype(nullable_string_dtype, na): tm.assert_series_equal(result, exp) +# -------------------------------------------------------------------------------------- +# str.endswith +# -------------------------------------------------------------------------------------- + + @pytest.mark.parametrize("dtype", [None, "category"]) @pytest.mark.parametrize("null_value", [None, np.nan, pd.NA]) @pytest.mark.parametrize("na", [True, False]) @@ -242,39 +326,50 @@ def test_endswith_nullable_string_dtype(nullable_string_dtype, na): tm.assert_series_equal(result, exp) +# -------------------------------------------------------------------------------------- +# str.replace +# -------------------------------------------------------------------------------------- + + def test_replace(any_string_dtype): - values = Series(["fooBAD__barBAD", np.nan], dtype=any_string_dtype) + ser = Series(["fooBAD__barBAD", np.nan], dtype=any_string_dtype) - result = values.str.replace("BAD[_]*", "", regex=True) + result = ser.str.replace("BAD[_]*", "", regex=True) expected = Series(["foobar", np.nan], dtype=any_string_dtype) tm.assert_series_equal(result, expected) - result = values.str.replace("BAD[_]*", "", n=1, regex=True) + +def test_replace_max_replacements(any_string_dtype): + ser = Series(["fooBAD__barBAD", np.nan], dtype=any_string_dtype) + expected = Series(["foobarBAD", np.nan], dtype=any_string_dtype) + result = ser.str.replace("BAD[_]*", "", n=1, regex=True) + tm.assert_series_equal(result, expected) + + expected = Series(["foo__barBAD", np.nan], dtype=any_string_dtype) + result = ser.str.replace("BAD", "", n=1, regex=False) tm.assert_series_equal(result, expected) def test_replace_mixed_object(): - mixed = Series( + ser = Series( ["aBAD", np.nan, "bBAD", True, datetime.today(), "fooBAD", None, 1, 2.0] ) - - result = Series(mixed).str.replace("BAD[_]*", "", regex=True) + result = Series(ser).str.replace("BAD[_]*", "", regex=True) expected = Series(["a", np.nan, "b", np.nan, np.nan, "foo", np.nan, np.nan, np.nan]) - assert isinstance(result, Series) - tm.assert_almost_equal(result, expected) + tm.assert_series_equal(result, expected) def test_replace_unicode(any_string_dtype): - values = Series([b"abcd,\xc3\xa0".decode("utf-8")], dtype=any_string_dtype) + ser = Series([b"abcd,\xc3\xa0".decode("utf-8")], dtype=any_string_dtype) expected = Series([b"abcd, \xc3\xa0".decode("utf-8")], dtype=any_string_dtype) - result = values.str.replace(r"(?<=\w),(?=\w)", ", ", flags=re.UNICODE, regex=True) + result = ser.str.replace(r"(?<=\w),(?=\w)", ", ", flags=re.UNICODE, regex=True) tm.assert_series_equal(result, expected) @pytest.mark.parametrize("repl", [None, 3, {"a": "b"}]) @pytest.mark.parametrize("data", [["a", "b", None], ["a", "b", "c", "ad"]]) -def test_replace_raises(any_string_dtype, index_or_series, repl, data): +def test_replace_wrong_repl_type_raises(any_string_dtype, index_or_series, repl, data): # https://github.com/pandas-dev/pandas/issues/13438 msg = "repl must be a string or callable" obj = index_or_series(data, dtype=any_string_dtype) @@ -284,11 +379,11 @@ def test_replace_raises(any_string_dtype, index_or_series, repl, data): def test_replace_callable(any_string_dtype): # GH 15055 - values = Series(["fooBAD__barBAD", np.nan], dtype=any_string_dtype) + ser = Series(["fooBAD__barBAD", np.nan], dtype=any_string_dtype) # test with callable repl = lambda m: m.group(0).swapcase() - result = values.str.replace("[a-z][A-Z]{2}", repl, n=2, regex=True) + result = ser.str.replace("[a-z][A-Z]{2}", repl, n=2, regex=True) expected = Series(["foObaD__baRbaD", np.nan], dtype=any_string_dtype) tm.assert_series_equal(result, expected) @@ -311,100 +406,195 @@ def test_replace_callable_raises(any_string_dtype, repl): def test_replace_callable_named_groups(any_string_dtype): # test regex named groups - values = Series(["Foo Bar Baz", np.nan], dtype=any_string_dtype) + ser = Series(["Foo Bar Baz", np.nan], dtype=any_string_dtype) pat = r"(?P\w+) (?P\w+) (?P\w+)" repl = lambda m: m.group("middle").swapcase() - result = values.str.replace(pat, repl, regex=True) + result = ser.str.replace(pat, repl, regex=True) expected = Series(["bAR", np.nan], dtype=any_string_dtype) tm.assert_series_equal(result, expected) def test_replace_compiled_regex(any_string_dtype): # GH 15446 - values = Series(["fooBAD__barBAD", np.nan], dtype=any_string_dtype) + ser = Series(["fooBAD__barBAD", np.nan], dtype=any_string_dtype) # test with compiled regex pat = re.compile(r"BAD_*") - result = values.str.replace(pat, "", regex=True) + result = ser.str.replace(pat, "", regex=True) expected = Series(["foobar", np.nan], dtype=any_string_dtype) tm.assert_series_equal(result, expected) - result = values.str.replace(pat, "", n=1, regex=True) + result = ser.str.replace(pat, "", n=1, regex=True) expected = Series(["foobarBAD", np.nan], dtype=any_string_dtype) tm.assert_series_equal(result, expected) def test_replace_compiled_regex_mixed_object(): pat = re.compile(r"BAD_*") - mixed = Series( + ser = Series( ["aBAD", np.nan, "bBAD", True, datetime.today(), "fooBAD", None, 1, 2.0] ) - - result = Series(mixed).str.replace(pat, "", regex=True) + result = Series(ser).str.replace(pat, "", regex=True) expected = Series(["a", np.nan, "b", np.nan, np.nan, "foo", np.nan, np.nan, np.nan]) - assert isinstance(result, Series) - tm.assert_almost_equal(result, expected) + tm.assert_series_equal(result, expected) def test_replace_compiled_regex_unicode(any_string_dtype): - values = Series([b"abcd,\xc3\xa0".decode("utf-8")], dtype=any_string_dtype) + ser = Series([b"abcd,\xc3\xa0".decode("utf-8")], dtype=any_string_dtype) expected = Series([b"abcd, \xc3\xa0".decode("utf-8")], dtype=any_string_dtype) pat = re.compile(r"(?<=\w),(?=\w)", flags=re.UNICODE) - result = values.str.replace(pat, ", ") + result = ser.str.replace(pat, ", ") tm.assert_series_equal(result, expected) def test_replace_compiled_regex_raises(any_string_dtype): # case and flags provided to str.replace will have no effect # and will produce warnings - values = Series(["fooBAD__barBAD__bad", np.nan], dtype=any_string_dtype) + ser = Series(["fooBAD__barBAD__bad", np.nan], dtype=any_string_dtype) pat = re.compile(r"BAD_*") msg = "case and flags cannot be set when pat is a compiled regex" with pytest.raises(ValueError, match=msg): - values.str.replace(pat, "", flags=re.IGNORECASE) + ser.str.replace(pat, "", flags=re.IGNORECASE) with pytest.raises(ValueError, match=msg): - values.str.replace(pat, "", case=False) + ser.str.replace(pat, "", case=False) with pytest.raises(ValueError, match=msg): - values.str.replace(pat, "", case=True) + ser.str.replace(pat, "", case=True) def test_replace_compiled_regex_callable(any_string_dtype): # test with callable - values = Series(["fooBAD__barBAD", np.nan], dtype=any_string_dtype) + ser = Series(["fooBAD__barBAD", np.nan], dtype=any_string_dtype) repl = lambda m: m.group(0).swapcase() pat = re.compile("[a-z][A-Z]{2}") - result = values.str.replace(pat, repl, n=2) + result = ser.str.replace(pat, repl, n=2) expected = Series(["foObaD__baRbaD", np.nan], dtype=any_string_dtype) tm.assert_series_equal(result, expected) -def test_replace_literal(any_string_dtype): +@pytest.mark.parametrize( + "regex,expected", [(True, ["bao", "bao", np.nan]), (False, ["bao", "foo", np.nan])] +) +def test_replace_literal(regex, expected, any_string_dtype): # GH16808 literal replace (regex=False vs regex=True) - values = Series(["f.o", "foo", np.nan], dtype=any_string_dtype) - expected = Series(["bao", "bao", np.nan], dtype=any_string_dtype) - result = values.str.replace("f.", "ba", regex=True) + ser = Series(["f.o", "foo", np.nan], dtype=any_string_dtype) + expected = Series(expected, dtype=any_string_dtype) + result = ser.str.replace("f.", "ba", regex=regex) tm.assert_series_equal(result, expected) - expected = Series(["bao", "foo", np.nan], dtype=any_string_dtype) - result = values.str.replace("f.", "ba", regex=False) - tm.assert_series_equal(result, expected) - # Cannot do a literal replace if given a callable repl or compiled - # pattern - callable_repl = lambda m: m.group(0).swapcase() - compiled_pat = re.compile("[a-z][A-Z]{2}") +def test_replace_literal_callable_raises(any_string_dtype): + ser = Series([], dtype=any_string_dtype) + repl = lambda m: m.group(0).swapcase() msg = "Cannot use a callable replacement when regex=False" with pytest.raises(ValueError, match=msg): - values.str.replace("abc", callable_repl, regex=False) + ser.str.replace("abc", repl, regex=False) + + +def test_replace_literal_compiled_raises(any_string_dtype): + ser = Series([], dtype=any_string_dtype) + pat = re.compile("[a-z][A-Z]{2}") msg = "Cannot use a compiled regex as replacement pattern with regex=False" with pytest.raises(ValueError, match=msg): - values.str.replace(compiled_pat, "", regex=False) + ser.str.replace(pat, "", regex=False) + + +def test_replace_moar(any_string_dtype): + # PR #1179 + ser = Series( + ["A", "B", "C", "Aaba", "Baca", "", np.nan, "CABA", "dog", "cat"], + dtype=any_string_dtype, + ) + + result = ser.str.replace("A", "YYY") + expected = Series( + ["YYY", "B", "C", "YYYaba", "Baca", "", np.nan, "CYYYBYYY", "dog", "cat"], + dtype=any_string_dtype, + ) + tm.assert_series_equal(result, expected) + + result = ser.str.replace("A", "YYY", case=False) + expected = Series( + [ + "YYY", + "B", + "C", + "YYYYYYbYYY", + "BYYYcYYY", + "", + np.nan, + "CYYYBYYY", + "dog", + "cYYYt", + ], + dtype=any_string_dtype, + ) + tm.assert_series_equal(result, expected) + + result = ser.str.replace("^.a|dog", "XX-XX ", case=False, regex=True) + expected = Series( + [ + "A", + "B", + "C", + "XX-XX ba", + "XX-XX ca", + "", + np.nan, + "XX-XX BA", + "XX-XX ", + "XX-XX t", + ], + dtype=any_string_dtype, + ) + tm.assert_series_equal(result, expected) + + +def test_replace_regex_default_warning(any_string_dtype): + # https://github.com/pandas-dev/pandas/pull/24809 + s = Series(["a", "b", "ac", np.nan, ""], dtype=any_string_dtype) + msg = ( + "The default value of regex will change from True to False in a " + "future version\\.$" + ) + with tm.assert_produces_warning(FutureWarning, match=msg): + result = s.str.replace("^.$", "a") + expected = Series(["a", "a", "ac", np.nan, ""], dtype=any_string_dtype) + tm.assert_series_equal(result, expected) + + +@pytest.mark.parametrize("regex", [True, False, None]) +def test_replace_regex_single_character(regex, any_string_dtype): + # https://github.com/pandas-dev/pandas/pull/24809 + + # The current behavior is to treat single character patterns as literal strings, + # even when ``regex`` is set to ``True``. + + s = Series(["a.b", ".", "b", np.nan, ""], dtype=any_string_dtype) + + if regex is None: + msg = re.escape( + "The default value of regex will change from True to False in a future " + "version. In addition, single character regular expressions will *not* " + "be treated as literal strings when regex=True." + ) + with tm.assert_produces_warning(FutureWarning, match=msg): + result = s.str.replace(".", "a", regex=regex) + else: + result = s.str.replace(".", "a", regex=regex) + + expected = Series(["aab", "a", "b", np.nan, ""], dtype=any_string_dtype) + tm.assert_series_equal(result, expected) + + +# -------------------------------------------------------------------------------------- +# str.match +# -------------------------------------------------------------------------------------- def test_match(any_string_dtype): @@ -484,6 +674,11 @@ def test_match_case_kwarg(any_string_dtype): tm.assert_series_equal(result, expected) +# -------------------------------------------------------------------------------------- +# str.fullmatch +# -------------------------------------------------------------------------------------- + + def test_fullmatch(any_string_dtype): # GH 32806 ser = Series( @@ -523,6 +718,11 @@ def test_fullmatch_case_kwarg(any_string_dtype): tm.assert_series_equal(result, expected) +# -------------------------------------------------------------------------------------- +# str.findall +# -------------------------------------------------------------------------------------- + + def test_findall(any_string_dtype): ser = Series(["fooBAD__barBAD", np.nan, "foo", "BAD"], dtype=any_string_dtype) result = ser.str.findall("BAD[_]*") @@ -563,6 +763,11 @@ def test_findall_mixed_object(): tm.assert_series_equal(result, expected) +# -------------------------------------------------------------------------------------- +# str.find +# -------------------------------------------------------------------------------------- + + def test_find(any_string_dtype): ser = Series( ["ABCDEFG", "BCDEFEF", "DEFGHIJEF", "EFGHEF", "XXXX"], dtype=any_string_dtype @@ -646,6 +851,11 @@ def test_find_nan(any_string_dtype): tm.assert_series_equal(result, expected) +# -------------------------------------------------------------------------------------- +# str.translate +# -------------------------------------------------------------------------------------- + + def test_translate(index_or_series, any_string_dtype): obj = index_or_series( ["abcdefg", "abcc", "cdddfg", "cdefggg"], dtype=any_string_dtype @@ -670,125 +880,7 @@ def test_translate_mixed_object(): tm.assert_series_equal(result, expected) -def test_contains_moar(any_string_dtype): - # PR #1179 - s = Series( - ["A", "B", "C", "Aaba", "Baca", "", np.nan, "CABA", "dog", "cat"], - dtype=any_string_dtype, - ) - - result = s.str.contains("a") - expected_dtype = "object" if any_string_dtype == "object" else "boolean" - expected = Series( - [False, False, False, True, True, False, np.nan, False, False, True], - dtype=expected_dtype, - ) - tm.assert_series_equal(result, expected) - - result = s.str.contains("a", case=False) - expected = Series( - [True, False, False, True, True, False, np.nan, True, False, True], - dtype=expected_dtype, - ) - tm.assert_series_equal(result, expected) - - result = s.str.contains("Aa") - expected = Series( - [False, False, False, True, False, False, np.nan, False, False, False], - dtype=expected_dtype, - ) - tm.assert_series_equal(result, expected) - - result = s.str.contains("ba") - expected = Series( - [False, False, False, True, False, False, np.nan, False, False, False], - dtype=expected_dtype, - ) - tm.assert_series_equal(result, expected) - - result = s.str.contains("ba", case=False) - expected = Series( - [False, False, False, True, True, False, np.nan, True, False, False], - dtype=expected_dtype, - ) - tm.assert_series_equal(result, expected) - - -def test_contains_nan(any_string_dtype): - # PR #14171 - s = Series([np.nan, np.nan, np.nan], dtype=any_string_dtype) - - result = s.str.contains("foo", na=False) - expected_dtype = np.bool_ if any_string_dtype == "object" else "boolean" - expected = Series([False, False, False], dtype=expected_dtype) - tm.assert_series_equal(result, expected) - - result = s.str.contains("foo", na=True) - expected = Series([True, True, True], dtype=expected_dtype) - tm.assert_series_equal(result, expected) - - result = s.str.contains("foo", na="foo") - if any_string_dtype == "object": - expected = Series(["foo", "foo", "foo"], dtype=np.object_) - else: - expected = Series([True, True, True], dtype="boolean") - tm.assert_series_equal(result, expected) - - result = s.str.contains("foo") - expected_dtype = "object" if any_string_dtype == "object" else "boolean" - expected = Series([np.nan, np.nan, np.nan], dtype=expected_dtype) - tm.assert_series_equal(result, expected) - - -def test_replace_moar(any_string_dtype): - # PR #1179 - s = Series( - ["A", "B", "C", "Aaba", "Baca", "", np.nan, "CABA", "dog", "cat"], - dtype=any_string_dtype, - ) - - result = s.str.replace("A", "YYY") - expected = Series( - ["YYY", "B", "C", "YYYaba", "Baca", "", np.nan, "CYYYBYYY", "dog", "cat"], - dtype=any_string_dtype, - ) - tm.assert_series_equal(result, expected) - - result = s.str.replace("A", "YYY", case=False) - expected = Series( - [ - "YYY", - "B", - "C", - "YYYYYYbYYY", - "BYYYcYYY", - "", - np.nan, - "CYYYBYYY", - "dog", - "cYYYt", - ], - dtype=any_string_dtype, - ) - tm.assert_series_equal(result, expected) - - result = s.str.replace("^.a|dog", "XX-XX ", case=False, regex=True) - expected = Series( - [ - "A", - "B", - "C", - "XX-XX ba", - "XX-XX ca", - "", - np.nan, - "XX-XX BA", - "XX-XX ", - "XX-XX t", - ], - dtype=any_string_dtype, - ) - tm.assert_series_equal(result, expected) +# -------------------------------------------------------------------------------------- def test_flags_kwarg(any_string_dtype):