def test_multiple_aggregators_with_dict_api():
s = Series(range(6), dtype="int64", name="series")
# nested renaming
msg = "nested renamer is not supported"
with pytest.raises(SpecificationError, match=msg):
s.agg({"foo": ["min", "max"], "bar": ["sum", "mean"]})
def test_no_args_raises(self):
gr = Series([1, 2]).groupby([0, 1])
with pytest.raises(TypeError, match="Must provide"):
gr.agg()
# but we do allow this
result = gr.agg([])
expected = DataFrame()
tm.assert_frame_equal(result, expected)
def test_demo():
# demonstration tests
s = Series(range(6), dtype="int64", name="series")
result = s.agg(["min", "max"])
expected = Series([0, 5], index=["min", "max"], name="series")
tm.assert_series_equal(result, expected)
result = s.agg({"foo": "min"})
expected = Series([0], index=["foo"], name="series")
tm.assert_series_equal(result, expected)
def test_non_callable_aggregates(self):
# test agg using non-callable series attributes
s = Series([1, 2, None])
# Calling agg w/ just a string arg same as calling s.arg
result = s.agg("size")
expected = s.size
assert result == expected
# test when mixed w/ callable reducers
result = s.agg(["size", "count", "mean"])
expected = Series({"size": 3.0, "count": 2.0, "mean": 1.5})
tm.assert_series_equal(result[expected.index], expected)
def test_non_callable_aggregates(self):
# test agg using non-callable series attributes
s = Series([1, 2, None])
# Calling agg w/ just a string arg same as calling s.arg
result = s.agg('size')
expected = s.size
assert result == expected
# test when mixed w/ callable reducers
result = s.agg(['size', 'count', 'mean'])
expected = Series(
OrderedDict([('size', 3.0), ('count', 2.0), ('mean', 1.5)]))
assert_series_equal(result[expected.index], expected)
def test_non_callable_aggregates(self):
# test agg using non-callable series attributes
s = Series([1, 2, None])
# Calling agg w/ just a string arg same as calling s.arg
result = s.agg('size')
expected = s.size
assert result == expected
# test when mixed w/ callable reducers
result = s.agg(['size', 'count', 'mean'])
expected = Series(OrderedDict({'size': 3.0,
'count': 2.0,
'mean': 1.5}))
assert_series_equal(result[expected.index], expected)
def numerical_summary(series: pd.Series) -> dict:
"""
Args:
series: series to summarize
Returns:
"""
aggregates = [
"mean",
"std",
"var",
"max",
"min",
"median",
"kurt",
"skew",
"sum",
"mad",
]
summary = series.agg(aggregates).to_dict()
quantiles = [0.05, 0.25, 0.5, 0.75, 0.95]
for percentile, value in series.quantile(quantiles).to_dict().items():
summary["quantile_{:d}".format(int(percentile * 100))] = value
summary["iqr"] = summary["quantile_75"] - summary["quantile_25"]
summary["range"] = summary["max"] - summary["min"]
summary["cv"] = summary["std"] / summary["mean"] if summary["mean"] else np.NaN
# TODO: only calculations for histogram, not the plotting
# summary['image'] = plotting.histogram(series)
return summary
def test_demo(self):
# demonstration tests
s = Series(range(6), dtype="int64", name="series")
result = s.agg(["min", "max"])
expected = Series([0, 5], index=["min", "max"], name="series")
tm.assert_series_equal(result, expected)
result = s.agg({"foo": "min"})
expected = Series([0], index=["foo"], name="series")
tm.assert_series_equal(result, expected)
# nested renaming
msg = "nested renamer is not supported"
with pytest.raises(SpecificationError, match=msg):
s.agg({"foo": ["min", "max"]})
def test_agg_args(args, kwargs, increment):
# GH 43357
def f(x, a=0, b=0, c=0):
return x + a + 10 * b + 100 * c
s = Series([1, 2])
result = s.agg(f, 0, *args, **kwargs)
expected = s + increment
tm.assert_series_equal(result, expected)
def test_demo(self):
# demonstration tests
s = Series(range(6), dtype='int64', name='series')
result = s.agg(['min', 'max'])
expected = Series([0, 5], index=['min', 'max'], name='series')
tm.assert_series_equal(result, expected)
result = s.agg({'foo': 'min'})
expected = Series([0], index=['foo'], name='series')
tm.assert_series_equal(result, expected)
# nested renaming
with tm.assert_produces_warning(FutureWarning):
result = s.agg({'foo': ['min', 'max']})
expected = DataFrame({
'foo': [0, 5]
}, index=['min', 'max']).unstack().rename('series')
tm.assert_series_equal(result, expected)
def test_demo(self):
# demonstration tests
s = Series(range(6), dtype='int64', name='series')
result = s.agg(['min', 'max'])
expected = Series([0, 5], index=['min', 'max'], name='series')
tm.assert_series_equal(result, expected)
result = s.agg({'foo': 'min'})
expected = Series([0], index=['foo'], name='series')
tm.assert_series_equal(result, expected)
# nested renaming
with tm.assert_produces_warning(FutureWarning):
result = s.agg({'foo': ['min', 'max']})
expected = DataFrame(
{'foo': [0, 5]},
index=['min', 'max']).unstack().rename('series')
tm.assert_series_equal(result, expected)
def test_demo(self):
# demonstration tests
s = Series(range(6), dtype="int64", name="series")
result = s.agg(["min", "max"])
expected = Series([0, 5], index=["min", "max"], name="series")
tm.assert_series_equal(result, expected)
result = s.agg({"foo": "min"})
expected = Series([0], index=["foo"], name="series")
tm.assert_series_equal(result, expected)
# nested renaming
with tm.assert_produces_warning(FutureWarning):
result = s.agg({"foo": ["min", "max"]})
expected = (DataFrame({
"foo": [0, 5]
}, index=["min", "max"]).unstack().rename("series"))
tm.assert_series_equal(result, expected)
def get_extremes(data: pd.Series) -> pd.Series:
"""Get the minimum and maximum values of the `data`.
Args:
data (pandas.Series): Data array.
Returns:
pandas.Series: An array of maximum and minimum values.
"""
extremes = data.agg([min, max])
return data[data.isin(extremes)]
def numerical_basic_summary(series: pd.Series) -> dict:
"""Summary with basic aggregates
Args:
series: series to summarize
Returns:
A summary of aggregates of `mean`, `std`, `var`, `min`, `max` and `sum`.
"""
aggregates = ["mean", "std", "var", "min", "max", "sum"]
summary = series.agg(aggregates).to_dict()
return summary
def test_multiple_aggregators_with_dict_api(self):
s = Series(range(6), dtype='int64', name='series')
# nested renaming
with tm.assert_produces_warning(FutureWarning):
result = s.agg({'foo': ['min', 'max'], 'bar': ['sum', 'mean']})
expected = DataFrame(
{'foo': [5.0, np.nan, 0.0, np.nan],
'bar': [np.nan, 2.5, np.nan, 15.0]},
columns=['foo', 'bar'],
index=['max', 'mean',
'min', 'sum']).unstack().rename('series')
tm.assert_series_equal(result.reindex_like(expected), expected)
def range_summary(series: pd.Series) -> dict:
"""Summarize min, max and calculate the range
Args:
series: series to summarize
Returns:
A dict with `min`, `max` and `range`.
"""
aggregates = ["min", "max"]
summary = series.agg(aggregates).to_dict()
summary["range"] = summary["max"] - summary["min"]
return summary
def test_numeric_only_series(arithmetic_win_operators, numeric_only, dtype):
# GH#46560
kernel = arithmetic_win_operators
ser = Series([1], dtype=dtype)
expanding = ser.expanding()
op = getattr(expanding, kernel)
if numeric_only and dtype is object:
msg = f"Expanding.{kernel} does not implement numeric_only"
with pytest.raises(NotImplementedError, match=msg):
op(numeric_only=numeric_only)
else:
result = op(numeric_only=numeric_only)
expected = ser.agg([kernel]).reset_index(drop=True).astype(float)
tm.assert_series_equal(result, expected)
def test_multiple_aggregators_with_dict_api(self):
s = Series(range(6), dtype='int64', name='series')
# nested renaming
with tm.assert_produces_warning(FutureWarning):
result = s.agg({'foo': ['min', 'max'], 'bar': ['sum', 'mean']})
expected = DataFrame(
{'foo': [5.0, np.nan, 0.0, np.nan],
'bar': [np.nan, 2.5, np.nan, 15.0]},
columns=['foo', 'bar'],
index=['max', 'mean',
'min', 'sum']).unstack().rename('series')
tm.assert_series_equal(result.reindex_like(expected), expected)
def test_multiple_aggregators_with_dict_api(self):
s = Series(range(6), dtype="int64", name="series")
# nested renaming
with tm.assert_produces_warning(FutureWarning):
result = s.agg({"foo": ["min", "max"], "bar": ["sum", "mean"]})
expected = (DataFrame(
{
"foo": [5.0, np.nan, 0.0, np.nan],
"bar": [np.nan, 2.5, np.nan, 15.0]
},
columns=["foo", "bar"],
index=["max", "mean", "min", "sum"],
).unstack().rename("series"))
tm.assert_series_equal(result.reindex_like(expected), expected)
def test_numeric_only_series(arithmetic_win_operators, numeric_only, dtype):
# GH#46560
kernel = arithmetic_win_operators
ser = Series([1], dtype=dtype)
ewm = ser.ewm(span=2, min_periods=1)
op = getattr(ewm, kernel, None)
if op is None:
# Nothing to test
return
if numeric_only and dtype is object:
msg = f"ExponentialMovingWindow.{kernel} does not implement numeric_only"
with pytest.raises(NotImplementedError, match=msg):
op(numeric_only=numeric_only)
else:
result = op(numeric_only=numeric_only)
expected = ser.agg([kernel]).reset_index(drop=True).astype(float)
tm.assert_series_equal(result, expected)
def bar_by_group(x: pd.Series, g: pd.Series, aggfunc="mean", *args, **kwargs):
"""
>>> mpg = data('mpg')
>>> bar_by_group(mpg.hwy, mpg['class'])
(<Figure size ... with 1 Axes>, <matplotlib.axes._subplots.AxesSubplot object at ...>)
"""
g = g.top_n(3)
fig, ax = plt.subplots()
x.groupby(g).agg(aggfunc).plot.bar(ax=ax, color="pink", width=1)
ax.set(title=f"{aggfunc} of {x.name} by {g.name}")
if aggfunc == "mean":
xbar = x.agg(aggfunc)
z = 2.58 # 99% ci
ci = z * (x.std() / math.sqrt(x.shape[0]))
ub, lb = xbar + ci, xbar - ci
ax.hlines(xbar, -0.5, 3.5, ls="--", color="gray")
ax.hlines([lb, ub], -0.5, 3.5, ls=":", color="gray")
return fig, ax
def test_series_agg_nested_renamer():
s = Series(range(6), dtype="int64", name="series")
msg = "nested renamer is not supported"
with pytest.raises(SpecificationError, match=msg):
s.agg({"foo": ["min", "max"]})
def test_mangle_series_groupby(self):
gr = Series([1, 2, 3, 4]).groupby([0, 0, 1, 1])
result = gr.agg([lambda x: 0, lambda x: 1])
expected = DataFrame({"<lambda_0>": [0, 0], "<lambda_1>": [1, 1]})
tm.assert_frame_equal(result, expected)
def test_mangled(self):
gr = Series([1, 2, 3]).groupby([0, 0, 1])
result = gr.agg(a=lambda x: 0, b=lambda x: 1)
expected = DataFrame({"a": [0, 0], "b": [1, 1]})
tm.assert_frame_equal(result, expected)
def test_series_named_agg_duplicates_no_raises(self):
# GH28426
gr = Series([1, 2, 3]).groupby([0, 0, 1])
grouped = gr.agg(a="sum", b="sum")
expected = DataFrame({"a": [3, 3], "b": [3, 3]})
tm.assert_frame_equal(expected, grouped)
def test_series_nested_renamer(renamer):
s = Series(range(6), dtype="int64", name="series")
msg = "nested renamer is not supported"
with pytest.raises(SpecificationError, match=msg):
s.agg(renamer)
print(ten)
print(ten.values)
print("Indexes:")
print(list(ten.index))
# Extract numbers by condition
pos_nums = nums[nums > 0]
print(f"There are {len(pos_nums)} positive numbers")
# You can plot a Series with matplotlib
_, axis = plt.subplots()
axis.plot(pos_nums)
plt.show()
# Find aggregate values (functions that work on sequences)
print(nums.agg(['min', 'max',
'sum'])) # Quoted values are accessible function names
print(ten.min(), ten.max())
print('3 largest:\n', ten.nlargest(3), sep='')
print('3 smallest:\n', ten.nsmallest(3), sep='')
# Map
print("Adding 50 to ten numbers:")
print(ten.map(lambda x: x + 50))
print(ten.map('I am {}'.format))
print(ten.transform([np.sqrt, np.exp])) # transform allows multiple "maps"
# Use apply for functions that take more than 1 parm (subsequent args in `args`)
print("Cubing ten numbers:")
cubes = ten.apply(operator.pow, args=(3, ))
print(cubes)
cubes2 = ten.pow(3) # Series has a pow function as well
