def test_mod(self):
for pser, psser in self.numeric_pser_psser_pairs:
self.assert_eq(pser % pser, psser % psser)
self.assert_eq(pser % pser.astype(bool),
psser % psser.astype(bool))
self.assert_eq(pser % True, psser % True)
if psser.dtype in [int, np.int32]:
self.assert_eq(
ps.Series([np.nan, np.nan, np.nan], dtype=float),
psser % False)
else:
self.assert_eq(
ps.Series([np.nan, np.nan, np.nan], dtype=psser.dtype),
psser % False)
with option_context("compute.ops_on_diff_frames", True):
for pser, psser in self.numeric_pser_psser_pairs:
self.assertRaises(
TypeError,
lambda: psser % self.non_numeric_pssers["string"])
self.assertRaises(
TypeError,
lambda: psser % self.non_numeric_pssers["datetime"])
self.assertRaises(
TypeError, lambda: psser % self.non_numeric_pssers["date"])
self.assertRaises(
TypeError,
lambda: psser % self.non_numeric_pssers["categorical"])
self.assert_eq(
(self.float_psser %
self.non_numeric_pssers["bool"]).sort_index(),
self.float_pser % self.non_numeric_psers["bool"],
)
def test_mul(self):
pser = self.pser
psser = self.psser
self.assert_eq((pser * 1).astype(float), psser * 1)
self.assert_eq((pser * 0.1).astype(float), psser * 0.1)
# In pandas, NA & False is NA, whereas NA & False is False in pandas-on-Spark
if LooseVersion(pd.__version__) >= LooseVersion("1.2.2"):
self.assert_eq(pser * True, psser * True)
self.assert_eq(ps.Series([False, False, False], dtype="boolean"), psser * False)
self.assert_eq(pser * pser, psser * psser)
else:
# Due to https://github.com/pandas-dev/pandas/issues/39410
self.assert_eq([True, False, pd._libs.missing.NAType()], (psser * True).tolist())
self.assert_eq(ps.Series([False, False, False]), (psser * False).astype(bool))
self.assert_eq([True, False, pd._libs.missing.NAType()], (psser * psser).tolist())
with option_context("compute.ops_on_diff_frames", True):
for pser, psser in self.numeric_pser_psser_pairs:
self.assert_eq(self.pser * pser, (self.psser * psser).sort_index(), almost=True)
for psser in self.non_numeric_pssers.values():
if not isinstance(psser.spark.data_type, BooleanType):
self.assertRaises(TypeError, lambda: self.psser * psser)
bool_pser = pd.Series([True, True, True])
bool_psser = ps.from_pandas(bool_pser)
if LooseVersion(pd.__version__) >= LooseVersion("1.2.2"):
self.assert_eq(self.pser * bool_pser, self.psser * bool_psser)
else:
# Due to https://github.com/pandas-dev/pandas/issues/39410
self.assert_eq(
[True, False, pd._libs.missing.NAType()], (self.psser * bool_psser).tolist()
)
def test_rfloordiv(self):
self.assert_eq((1 // self.psser).astype(float), ps.Series([1.0, np.inf, np.nan]))
self.assert_eq((0.1 // self.psser).astype(float), ps.Series([0.0, np.inf, np.nan]))
self.assertRaises(TypeError, lambda: "x" // self.psser)
self.assertRaises(TypeError, lambda: True // self.psser)
self.assertRaises(TypeError, lambda: datetime.date(1994, 1, 1) // self.psser)
self.assertRaises(TypeError, lambda: datetime.datetime(1994, 1, 1) // self.psser)
def test_expanding_count(self):
# The behaviour of Expanding.count are different between pandas>=1.0.0 and lower,
# and we're following the behaviour of latest version of pandas.
if LooseVersion(pd.__version__) >= LooseVersion("1.0.0"):
self._test_expanding_func("count")
else:
# Series
idx = np.random.rand(3)
psser = ps.Series([1, 2, 3], index=idx, name="a")
expected_result = pd.Series([None, 2.0, 3.0], index=idx, name="a")
self.assert_eq(psser.expanding(2).count().sort_index(), expected_result.sort_index())
self.assert_eq(psser.expanding(2).count().sum(), expected_result.sum())
# MultiIndex
midx = pd.MultiIndex.from_tuples([("a", "x"), ("a", "y"), ("b", "z")])
psser = ps.Series([1, 2, 3], index=midx, name="a")
expected_result = pd.Series([None, 2.0, 3.0], index=midx, name="a")
self.assert_eq(psser.expanding(2).count().sort_index(), expected_result.sort_index())
# DataFrame
psdf = ps.DataFrame({"a": [1, 2, 3, 2], "b": [4.0, 2.0, 3.0, 1.0]})
expected_result = pd.DataFrame({"a": [None, 2.0, 3.0, 4.0], "b": [None, 2.0, 3.0, 4.0]})
self.assert_eq(psdf.expanding(2).count().sort_index(), expected_result.sort_index())
self.assert_eq(psdf.expanding(2).count().sum(), expected_result.sum())
# MultiIndex columns
idx = np.random.rand(4)
psdf = ps.DataFrame({"a": [1, 2, 3, 2], "b": [4.0, 2.0, 3.0, 1.0]}, index=idx)
psdf.columns = pd.MultiIndex.from_tuples([("a", "x"), ("a", "y")])
expected_result = pd.DataFrame(
{("a", "x"): [None, 2.0, 3.0, 4.0], ("a", "y"): [None, 2.0, 3.0, 4.0]},
index=idx,
)
self.assert_eq(psdf.expanding(2).count().sort_index(), expected_result.sort_index())
def test_neg(self):
# pandas raises "TypeError: bad operand type for unary -: 'FloatingArray'"
for dtype in self.fractional_extension_dtypes:
self.assert_eq(
ps.Series([-0.1, -0.2, -0.3, None], dtype=dtype),
-ps.Series([0.1, 0.2, 0.3, None], dtype=dtype),
)
def test_rmod(self):
self.assert_eq(ps.Series([0, np.nan, np.nan], dtype=float), 1 % self.psser)
self.assert_eq(
ps.Series([0.10000000000000009, np.nan, np.nan], dtype=float),
0.1 % self.psser,
)
self.assertRaises(TypeError, lambda: datetime.date(1994, 1, 1) % self.psser)
self.assertRaises(TypeError, lambda: True % self.psser)
def test_rmod(self):
# 1 % False is 0.0 in pandas
self.assert_eq(ps.Series([0, 0, None], dtype=float), 1 % self.psser)
# 0.1 / True is 0.1 in pandas
self.assert_eq(
ps.Series([0.10000000000000009, 0.10000000000000009, None], dtype=float),
0.1 % self.psser,
)
self.assertRaises(TypeError, lambda: datetime.date(1994, 1, 1) % self.psser)
self.assertRaises(TypeError, lambda: True % self.psser)
def test_rfloordiv(self):
if LooseVersion(pd.__version__) >= LooseVersion("0.25.3"):
self.assert_eq(1 // self.pser, 1 // self.psser)
self.assert_eq(0.1 // self.pser, 0.1 // self.psser)
else:
self.assert_eq(1 // self.psser, ps.Series([1.0, 1.0, np.inf]))
self.assert_eq(0.1 // self.psser, ps.Series([0.0, 0.0, np.inf]))
self.assertRaises(TypeError, lambda: "x" // self.psser)
self.assertRaises(TypeError, lambda: True // self.psser)
self.assertRaises(TypeError, lambda: datetime.date(1994, 1, 1) // self.psser)
self.assertRaises(TypeError, lambda: datetime.datetime(1994, 1, 1) // self.psser)
def test_rmul(self):
self.assert_eq((1 * self.pser).astype(float), 1 * self.psser)
self.assert_eq((0.1 * self.pser).astype(float), 0.1 * self.psser)
self.assertRaises(TypeError, lambda: "x" * self.psser)
# In pandas, NA & False is NA, whereas NA & False is False in pandas-on-Spark
if LooseVersion(pd.__version__) >= LooseVersion("1.2.2"):
self.assert_eq(True * self.pser, True * self.psser)
self.assert_eq(ps.Series([False, False, False], dtype="boolean"), False * self.psser)
else:
# Due to https://github.com/pandas-dev/pandas/issues/39410
self.assert_eq(ps.Series([False, False, False]), (False * self.psser).astype(bool))
self.assertRaises(TypeError, lambda: datetime.date(1994, 1, 1) * self.psser)
self.assertRaises(TypeError, lambda: datetime.datetime(1994, 1, 1) * self.psser)
def test_get_dummies(self):
for pdf_or_ps in [
pd.Series([1, 1, 1, 2, 2, 1, 3, 4]),
# pd.Series([1, 1, 1, 2, 2, 1, 3, 4], dtype='category'),
# pd.Series(pd.Categorical([1, 1, 1, 2, 2, 1, 3, 4],
# categories=[4, 3, 2, 1])),
pd.DataFrame({
"a": [1, 2, 3, 4, 4, 3, 2, 1],
# 'b': pd.Categorical(list('abcdabcd')),
"b": list("abcdabcd"),
}),
pd.DataFrame({
10: [1, 2, 3, 4, 4, 3, 2, 1],
20: list("abcdabcd")
}),
]:
psdf_or_psser = ps.from_pandas(pdf_or_ps)
self.assert_eq(ps.get_dummies(psdf_or_psser),
pd.get_dummies(pdf_or_ps, dtype=np.int8))
psser = ps.Series([1, 1, 1, 2, 2, 1, 3, 4])
with self.assertRaisesRegex(
NotImplementedError,
"get_dummies currently does not support sparse"):
ps.get_dummies(psser, sparse=True)
def test_accessor_works(self):
register_series_accessor("test")(CustomAccessor)
s = ps.Series([1, 2])
assert s.test.obj is s
assert s.test.prop == "item"
assert s.test.method() == "item"
def test_floordiv(self):
for pser, psser in self.numeric_pser_psser_pairs:
if psser.dtype == float:
self.assert_eq(pser // pser, psser // psser)
self.assert_eq(pser // pser.astype(bool), psser // psser.astype(bool))
self.assert_eq(pser // True, psser // True)
self.assert_eq(pser // False, psser // False)
with option_context("compute.ops_on_diff_frames", True):
for pser, psser in self.numeric_pser_psser_pairs:
self.assertRaises(TypeError, lambda: psser // self.non_numeric_pssers["string"])
self.assertRaises(TypeError, lambda: psser // self.non_numeric_pssers["datetime"])
self.assertRaises(TypeError, lambda: psser // self.non_numeric_pssers["date"])
self.assertRaises(
TypeError, lambda: psser // self.non_numeric_pssers["categorical"]
)
if LooseVersion(pd.__version__) >= LooseVersion("0.25.3"):
self.assert_eq(
(self.float_psser // self.non_numeric_pssers["bool"]).sort_index(),
self.float_pser // self.non_numeric_psers["bool"],
)
else:
self.assert_eq(
(self.float_pser // self.non_numeric_psers["bool"]).sort_index(),
ps.Series([1.0, 2.0, np.inf]),
)
def test_ne(self):
pdf, psdf = self.pdf, self.psdf
pser, psser = pdf["this_numeric_cat"], psdf["this_numeric_cat"]
ordered_pser, ordered_psser = (
pdf["this_ordered_numeric_cat"],
psdf["this_ordered_numeric_cat"],
)
self.assert_eq(ordered_pser != 1, ordered_psser != 1)
self.assert_eq(pser != pser, psser != psser)
self.assert_eq(ordered_pser != ordered_pser, ordered_psser != ordered_psser)
pser, psser = pdf["this_string_cat"], psdf["this_string_cat"]
ordered_pser, ordered_psser = (
pdf["this_ordered_string_cat"],
psdf["this_ordered_string_cat"],
)
self.assert_eq(pser != "x", psser != "x")
self.assert_eq(pser != pser, psser != psser)
self.assert_eq(ordered_pser != ordered_pser, ordered_psser != ordered_psser)
self.assertRaisesRegex(
TypeError,
"Cannot compare a Categorical with a scalar, which is not a category",
lambda: ordered_psser != 4,
)
self.assertRaisesRegex(
TypeError,
"Cannot compare a Categorical with a scalar, which is not a category",
lambda: ordered_psser != "a",
)
self.assertRaisesRegex(
TypeError,
"Cannot compare a Categorical with the given type",
lambda: ordered_psser != ps.Series([1, 2, 3]),
)
self.assertRaisesRegex(
TypeError,
"The operation can not be applied to list.",
lambda: ordered_psser != [1, 2, 3],
)
self.assert_eq(
pdf["this_numeric_cat"] != pdf["that_numeric_cat"],
psdf["this_numeric_cat"] != psdf["that_numeric_cat"],
)
self.assert_eq(
pdf["this_string_cat"] != pdf["that_string_cat"],
psdf["this_string_cat"] != psdf["that_string_cat"],
)
self.assert_eq(
pdf["this_string_cat"] != pdf["this_given_cat_string_cat"],
psdf["this_string_cat"] != psdf["this_given_cat_string_cat"],
)
pser1 = pd.Series(pd.Categorical(list("abca")))
pser2 = pd.Series(pd.Categorical(list("bcaa"), categories=list("bca")))
psser1 = ps.from_pandas(pser1)
psser2 = ps.from_pandas(pser2)
with option_context("compute.ops_on_diff_frames", True):
self.assert_eq(pser1 != pser2, (psser1 != psser2).sort_index())
def test_ge(self):
ordered_pser = self.ordered_pser
ordered_psser = self.ordered_psser
self.assert_eq(ordered_pser >= ordered_pser, ordered_psser >= ordered_psser)
with option_context("compute.ops_on_diff_frames", True):
self.assert_eq(
ordered_pser >= self.other_ordered_pser, ordered_psser >= self.other_ordered_psser
)
self.assertRaisesRegex(
TypeError,
"Unordered Categoricals can only compare equality or not",
lambda: self.unordered_psser >= ordered_psser,
)
self.assertRaisesRegex(
TypeError,
"Categoricals can only be compared if 'categories' are the same",
lambda: ordered_psser >= self.unordered_psser,
)
self.assertRaisesRegex(
TypeError,
"Cannot compare a Categorical with the given type",
lambda: ordered_psser >= ps.Series([1, 2, 3]),
)
self.assertRaisesRegex(
TypeError,
"Cannot compare a Categorical with the given type",
lambda: ordered_psser >= [1, 2, 3],
)
self.assertRaisesRegex(
TypeError,
"Cannot compare a Categorical with the given type",
lambda: ordered_psser >= 1,
)
def test_rpow(self):
self.assert_eq(1 ** self.psser, ps.Series([1, 1, 1], dtype=float))
self.assert_eq((0.1 ** self.pser).astype(float), 0.1 ** self.psser)
self.assertRaises(TypeError, lambda: "x" ** self.psser)
self.assertRaises(TypeError, lambda: True ** self.psser)
self.assertRaises(TypeError, lambda: datetime.date(1994, 1, 1) ** self.psser)
self.assertRaises(TypeError, lambda: datetime.datetime(1994, 1, 1) ** self.psser)
def test_to_timedelta(self):
self.assert_eq(
ps.to_timedelta("1 days 06:05:01.00003"),
pd.to_timedelta("1 days 06:05:01.00003"),
)
self.assert_eq(
ps.to_timedelta("15.5us"),
pd.to_timedelta("15.5us"),
)
self.assert_eq(
ps.to_timedelta(["1 days 06:05:01.00003", "15.5us", "nan"]),
pd.to_timedelta(["1 days 06:05:01.00003", "15.5us", "nan"]),
)
self.assert_eq(
ps.to_timedelta(np.arange(5), unit="s"),
pd.to_timedelta(np.arange(5), unit="s"),
)
self.assert_eq(
ps.to_timedelta(ps.Series([1, 2]), unit="d"),
pd.to_timedelta(pd.Series([1, 2]), unit="d"),
)
self.assert_eq(
ps.to_timedelta(pd.Series([1, 2]), unit="d"),
pd.to_timedelta(pd.Series([1, 2]), unit="d"),
)
def test_from_to_pandas(self):
sparse_values = {0: 0.1, 1: 1.1}
sparse_vector = SparseVector(len(sparse_values), sparse_values)
pser = pd.Series([sparse_vector])
psser = ps.Series([sparse_vector])
self.assert_eq(pser, psser.to_pandas())
self.assert_eq(ps.from_pandas(pser), psser)
def test_groupby_expanding_count(self):
# The behaviour of ExpandingGroupby.count are different between pandas>=1.0.0 and lower,
# and we're following the behaviour of latest version of pandas.
if LooseVersion(pd.__version__) >= LooseVersion("1.0.0"):
self._test_groupby_expanding_func("count")
else:
# Series
psser = ps.Series([1, 2, 3])
kkey = ps.Series([1, 2, 3], name="a")
midx = pd.MultiIndex.from_tuples(
list(
zip(kkey.to_pandas().values,
psser.index.to_pandas().values)),
names=["a", None],
)
expected_result = pd.Series([np.nan, np.nan, np.nan], index=midx)
self.assert_eq(
psser.groupby(kkey).expanding(2).count().sort_index(),
expected_result.sort_index())
# DataFrame
psdf = ps.DataFrame({"a": [1, 2, 3, 2], "b": [4.0, 2.0, 3.0, 1.0]})
kkey = ps.Series([1, 2, 3, 2], name="a")
midx = pd.MultiIndex.from_tuples([(1, 0), (2, 1), (2, 3), (3, 2)],
names=["a", None])
expected_result = pd.DataFrame(
{
"a": [None, None, 2.0, None],
"b": [None, None, 2.0, None]
},
index=midx)
self.assert_eq(
psdf.groupby(kkey).expanding(2).count().sort_index(),
expected_result.sort_index())
expected_result = pd.Series([None, None, 2.0, None],
index=midx,
name="b")
self.assert_eq(
psdf.groupby(kkey)["b"].expanding(2).count().sort_index(),
expected_result.sort_index(),
)
expected_result = pd.DataFrame({"b": [None, None, 2.0, None]},
index=midx)
self.assert_eq(
psdf.groupby(kkey)[["b"]].expanding(2).count().sort_index(),
expected_result.sort_index(),
)
def test_categorical_series(self):
pser = pd.Series([1, 2, 3], dtype="category")
kser = ps.Series([1, 2, 3], dtype="category")
self.assert_eq(kser, pser)
self.assert_eq(kser.cat.categories, pser.cat.categories)
self.assert_eq(kser.cat.codes, pser.cat.codes)
self.assert_eq(kser.cat.ordered, pser.cat.ordered)
def complex_psdf(self):
pssers = {
"this_array": self.psser,
"that_array": ps.Series([[2, 3, 4]]),
"this_struct": ps.Index([("x", 1)]).to_series().reset_index(drop=True),
"that_struct": ps.Index([("a", 2)]).to_series().reset_index(drop=True),
}
return ps.concat(pssers, axis=1)
def test_from_to_pandas(self):
data = [0.1, 0.2, 0.3, None]
dtypes = ["Float32", "Float64"]
for dtype in dtypes:
pser = pd.Series(data, dtype=dtype)
psser = ps.Series(data, dtype=dtype)
self.check_extension(pser, psser.to_pandas())
self.check_extension(ps.from_pandas(pser), psser)
def test_from_to_pandas(self):
data = [1, 2, 3, None]
dtypes = ["Int8", "Int16", "Int32", "Int64"]
for dtype in dtypes:
pser = pd.Series(data, dtype=dtype)
psser = ps.Series(data, dtype=dtype)
self.check_extension(pser, psser.to_pandas())
self.check_extension(ps.from_pandas(pser), psser)
def test_raises_attr_error(self):
with ensure_removed(ps.Series, "bad"):
class Bad:
def __init__(self, data):
raise AttributeError("whoops")
with self.assertRaises(AttributeError):
ps.Series([1, 2], dtype=object).bad
def test_multiindex_transform_negative(self):
with self.assertRaisesRegex(
NotImplementedError, "MultiIndex does not support spark.transform yet"
):
midx = pd.MultiIndex(
[["lama", "cow", "falcon"], ["speed", "weight", "length"]],
[[0, 0, 0, 1, 1, 1, 2, 2, 2], [1, 1, 1, 1, 1, 2, 1, 2, 2]],
)
s = ps.Series([45, 200, 1.2, 30, 250, 1.5, 320, 1, 0.3], index=midx)
s.index.spark.transform(lambda scol: scol)
def test_from_to_pandas(self):
data = [
datetime.date(1994, 1, 31),
datetime.date(1994, 2, 1),
datetime.date(1994, 2, 2)
]
pser = pd.Series(data)
psser = ps.Series(data)
self.assert_eq(pser, psser.to_pandas())
self.assert_eq(ps.from_pandas(pser), psser)
def test_radd(self):
self.assert_eq((1 + self.pser).astype(float), 1 + self.psser)
self.assert_eq((0.1 + self.pser).astype(float), 0.1 + self.psser)
self.assertRaises(TypeError, lambda: "x" + self.psser)
# In pandas, NA | True is NA, whereas NA | True is True in pandas-on-Spark
self.check_extension(ps.Series([True, True, True], dtype="boolean"), True + self.psser)
self.check_extension(False + self.pser, False + self.psser)
self.assertRaises(TypeError, lambda: datetime.date(1994, 1, 1) + self.psser)
self.assertRaises(TypeError, lambda: datetime.datetime(1994, 1, 1) + self.psser)
def test_rmul(self):
self.assert_eq((1 * self.pser).astype(float), 1 * self.psser)
self.assert_eq((0.1 * self.pser).astype(float), 0.1 * self.psser)
self.assertRaises(TypeError, lambda: "x" * self.psser)
# In pandas, NA & False is NA, whereas NA & False is False in pandas-on-Spark
self.check_extension(True * self.pser, True * self.psser)
self.check_extension(ps.Series([False, False, False], dtype="boolean"), False * self.psser)
self.assertRaises(TypeError, lambda: datetime.date(1994, 1, 1) * self.psser)
self.assertRaises(TypeError, lambda: datetime.datetime(1994, 1, 1) * self.psser)
def test_eq(self):
pdf, psdf = self.pdf, self.psdf
pser, psser = pdf["this_numeric_cat"], psdf["this_numeric_cat"]
ordered_pser, ordered_psser = (
pdf["this_ordered_numeric_cat"],
psdf["this_ordered_numeric_cat"],
)
self.assert_eq(ordered_pser == 1, ordered_psser == 1)
self.assert_eq(pser == pser, psser == psser)
self.assert_eq(ordered_pser == ordered_pser,
ordered_psser == ordered_psser)
pser, psser = pdf["this_string_cat"], psdf["this_string_cat"]
ordered_pser, ordered_psser = (
pdf["this_ordered_string_cat"],
psdf["this_ordered_string_cat"],
)
self.assert_eq(pser == "x", psser == "x")
self.assert_eq(pser == pser, psser == psser)
self.assert_eq(ordered_pser == ordered_pser,
ordered_psser == ordered_psser)
self.assertRaisesRegex(
TypeError,
"Cannot compare a Categorical with a scalar, which is not a category",
lambda: ordered_psser == 4,
)
self.assertRaisesRegex(
TypeError,
"Cannot compare a Categorical with a scalar, which is not a category",
lambda: ordered_psser == "a",
)
self.assertRaisesRegex(
TypeError,
"Cannot compare a Categorical with the given type",
lambda: ordered_psser == ps.Series([1, 2, 3]),
)
self.assertRaisesRegex(
TypeError,
"Cannot compare a Categorical with the given type",
lambda: ordered_psser == [1, 2, 3],
)
self.assert_eq(
pdf["this_numeric_cat"] == pdf["that_numeric_cat"],
psdf["this_numeric_cat"] == psdf["that_numeric_cat"],
)
self.assert_eq(
pdf["this_string_cat"] == pdf["that_string_cat"],
psdf["this_string_cat"] == psdf["that_string_cat"],
)
def test_lt(self):
pdf, psdf = self.pdf, self.psdf
ordered_pser, ordered_psser = (
pdf["this_ordered_numeric_cat"],
psdf["this_ordered_numeric_cat"],
)
self.assert_eq(ordered_pser < 1, ordered_psser < 1)
self.assert_eq(ordered_pser < ordered_pser,
ordered_psser < ordered_psser)
ordered_pser, ordered_psser = (
pdf["this_ordered_string_cat"],
psdf["this_ordered_string_cat"],
)
self.assert_eq(ordered_pser < "x", ordered_psser < "x")
self.assert_eq(ordered_pser < ordered_pser,
ordered_psser < ordered_psser)
self.assertRaisesRegex(
TypeError,
"Unordered Categoricals can only compare equality or not",
lambda: self.psser < ordered_psser,
)
self.assertRaisesRegex(
TypeError,
"Cannot compare a Categorical with a scalar, which is not a category",
lambda: ordered_psser < 4,
)
self.assertRaisesRegex(
TypeError,
"Cannot compare a Categorical with a scalar, which is not a category",
lambda: ordered_psser < "a",
)
self.assertRaisesRegex(
TypeError,
"Cannot compare a Categorical with the given type",
lambda: ordered_psser < ps.Series([1, 2, 3]),
)
self.assertRaisesRegex(
TypeError,
"The operation can not be applied to list",
lambda: ordered_psser < [1, 2, 3],
)
self.assert_eq(
pdf["this_ordered_numeric_cat"] < pdf["that_ordered_numeric_cat"],
psdf["this_ordered_numeric_cat"] <
psdf["that_ordered_numeric_cat"],
)
self.assert_eq(
pdf["this_ordered_string_cat"] < pdf["that_ordered_string_cat"],
psdf["this_ordered_string_cat"] < psdf["that_ordered_string_cat"],
)
def test_mul(self):
self.assertRaises(TypeError, lambda: self.psser * "x")
self.assert_eq(self.pser * 1, self.psser * 1)
with option_context("compute.ops_on_diff_frames", True):
for pser, psser in self.pser_psser_pairs:
if psser.dtype in [np.int32, np.int64]:
self.assert_eq(
ps.Series(["x", "yy", "zzz", None]).astype("string"),
(self.psser * psser).sort_index(),
)
else:
self.assertRaises(TypeError, lambda: self.psser * psser)
