FM / methods

/usr/local/lib64/python3.6/site-packages/pandas/tests/series/methods/

/usr/local/lib64/python3.6/site-packages/pandas/tests/series/methods

Name	Size	Mode	Actions
__pycache__/	-	0755	rm
test_align.py	5359	0644	edit dl rm
test_append.py	9600	0644	edit dl rm
test_argsort.py	2249	0644	edit dl rm
test_asfreq.py	3616	0644	edit dl rm
test_asof.py	5515	0644	edit dl rm
test_astype.py	2628	0644	edit dl rm
test_at_time.py	2629	0644	edit dl rm
test_autocorr.py	999	0644	edit dl rm
test_between.py	1197	0644	edit dl rm
test_between_time.py	5086	0644	edit dl rm
test_clip.py	3384	0644	edit dl rm
test_combine.py	627	0644	edit dl rm
test_combine_first.py	3411	0644	edit dl rm
test_compare.py	3734	0644	edit dl rm
test_convert_dtypes.py	9914	0644	edit dl rm
test_count.py	1123	0644	edit dl rm
test_cov_corr.py	5215	0644	edit dl rm
test_describe.py	4640	0644	edit dl rm
test_diff.py	2331	0644	edit dl rm
test_drop.py	2986	0644	edit dl rm
test_droplevel.py	629	0644	edit dl rm
test_drop_duplicates.py	6850	0644	edit dl rm
test_duplicated.py	996	0644	edit dl rm
test_equals.py	1295	0644	edit dl rm
test_explode.py	3538	0644	edit dl rm
test_fillna.py	6513	0644	edit dl rm
test_first_and_last.py	2042	0644	edit dl rm
test_head_tail.py	343	0644	edit dl rm
test_interpolate.py	27757	0644	edit dl rm
test_isin.py	3445	0644	edit dl rm
test_nlargest.py	7121	0644	edit dl rm
test_pct_change.py	2968	0644	edit dl rm
test_quantile.py	6810	0644	edit dl rm
test_rank.py	20287	0644	edit dl rm
test_reindex_like.py	1245	0644	edit dl rm
test_rename.py	3378	0644	edit dl rm
test_rename_axis.py	1503	0644	edit dl rm
test_replace.py	15559	0644	edit dl rm
test_reset_index.py	4636	0644	edit dl rm
test_round.py	1970	0644	edit dl rm
test_searchsorted.py	2121	0644	edit dl rm
test_shift.py	12595	0644	edit dl rm
test_sort_index.py	12277	0644	edit dl rm
test_sort_values.py	7981	0644	edit dl rm
test_to_dict.py	742	0644	edit dl rm
test_to_period.py	1755	0644	edit dl rm
test_to_timestamp.py	2616	0644	edit dl rm
test_truncate.py	5557	0644	edit dl rm
test_tz_convert.py	1008	0644	edit dl rm
test_tz_localize.py	3108	0644	edit dl rm
test_unstack.py	4208	0644	edit dl rm
test_update.py	4213	0644	edit dl rm
test_value_counts.py	8136	0644	edit dl rm
__init__.py	225	0644	edit dl rm

Edit: /usr/local/lib64/python3.6/site-packages/pandas/tests/series/methods/test_value_counts.py (8136B)

import numpy as np
import pytest

import pandas as pd
from pandas import Categorical, CategoricalIndex, Series
import pandas._testing as tm

class TestSeriesValueCounts:
    def test_value_counts_datetime(self):
        # most dtypes are tested in tests/base
        values = [
            pd.Timestamp("2011-01-01 09:00"),
            pd.Timestamp("2011-01-01 10:00"),
            pd.Timestamp("2011-01-01 11:00"),
            pd.Timestamp("2011-01-01 09:00"),
            pd.Timestamp("2011-01-01 09:00"),
            pd.Timestamp("2011-01-01 11:00"),
        ]

exp_idx = pd.DatetimeIndex(
            ["2011-01-01 09:00", "2011-01-01 11:00", "2011-01-01 10:00"]
        )
        exp = pd.Series([3, 2, 1], index=exp_idx, name="xxx")

ser = pd.Series(values, name="xxx")
        tm.assert_series_equal(ser.value_counts(), exp)
        # check DatetimeIndex outputs the same result
        idx = pd.DatetimeIndex(values, name="xxx")
        tm.assert_series_equal(idx.value_counts(), exp)

# normalize
        exp = pd.Series(np.array([3.0, 2.0, 1]) / 6.0, index=exp_idx, name="xxx")
        tm.assert_series_equal(ser.value_counts(normalize=True), exp)
        tm.assert_series_equal(idx.value_counts(normalize=True), exp)

def test_value_counts_datetime_tz(self):
        values = [
            pd.Timestamp("2011-01-01 09:00", tz="US/Eastern"),
            pd.Timestamp("2011-01-01 10:00", tz="US/Eastern"),
            pd.Timestamp("2011-01-01 11:00", tz="US/Eastern"),
            pd.Timestamp("2011-01-01 09:00", tz="US/Eastern"),
            pd.Timestamp("2011-01-01 09:00", tz="US/Eastern"),
            pd.Timestamp("2011-01-01 11:00", tz="US/Eastern"),
        ]

exp_idx = pd.DatetimeIndex(
            ["2011-01-01 09:00", "2011-01-01 11:00", "2011-01-01 10:00"],
            tz="US/Eastern",
        )
        exp = pd.Series([3, 2, 1], index=exp_idx, name="xxx")

ser = pd.Series(values, name="xxx")
        tm.assert_series_equal(ser.value_counts(), exp)
        idx = pd.DatetimeIndex(values, name="xxx")
        tm.assert_series_equal(idx.value_counts(), exp)

exp = pd.Series(np.array([3.0, 2.0, 1]) / 6.0, index=exp_idx, name="xxx")
        tm.assert_series_equal(ser.value_counts(normalize=True), exp)
        tm.assert_series_equal(idx.value_counts(normalize=True), exp)

def test_value_counts_period(self):
        values = [
            pd.Period("2011-01", freq="M"),
            pd.Period("2011-02", freq="M"),
            pd.Period("2011-03", freq="M"),
            pd.Period("2011-01", freq="M"),
            pd.Period("2011-01", freq="M"),
            pd.Period("2011-03", freq="M"),
        ]

exp_idx = pd.PeriodIndex(["2011-01", "2011-03", "2011-02"], freq="M")
        exp = pd.Series([3, 2, 1], index=exp_idx, name="xxx")

ser = pd.Series(values, name="xxx")
        tm.assert_series_equal(ser.value_counts(), exp)
        # check DatetimeIndex outputs the same result
        idx = pd.PeriodIndex(values, name="xxx")
        tm.assert_series_equal(idx.value_counts(), exp)

def test_value_counts_categorical_ordered(self):
        # most dtypes are tested in tests/base
        values = pd.Categorical([1, 2, 3, 1, 1, 3], ordered=True)

exp_idx = pd.CategoricalIndex([1, 3, 2], categories=[1, 2, 3], ordered=True)
        exp = pd.Series([3, 2, 1], index=exp_idx, name="xxx")

ser = pd.Series(values, name="xxx")
        tm.assert_series_equal(ser.value_counts(), exp)
        # check CategoricalIndex outputs the same result
        idx = pd.CategoricalIndex(values, name="xxx")
        tm.assert_series_equal(idx.value_counts(), exp)

def test_value_counts_categorical_not_ordered(self):
        values = pd.Categorical([1, 2, 3, 1, 1, 3], ordered=False)

exp_idx = pd.CategoricalIndex([1, 3, 2], categories=[1, 2, 3], ordered=False)
        exp = pd.Series([3, 2, 1], index=exp_idx, name="xxx")

def test_value_counts_categorical(self):
        # GH#12835
        cats = Categorical(list("abcccb"), categories=list("cabd"))
        ser = Series(cats, name="xxx")
        res = ser.value_counts(sort=False)

exp_index = CategoricalIndex(list("cabd"), categories=cats.categories)
        exp = Series([3, 1, 2, 0], name="xxx", index=exp_index)
        tm.assert_series_equal(res, exp)

res = ser.value_counts(sort=True)

exp_index = CategoricalIndex(list("cbad"), categories=cats.categories)
        exp = Series([3, 2, 1, 0], name="xxx", index=exp_index)
        tm.assert_series_equal(res, exp)

# check object dtype handles the Series.name as the same
        # (tested in tests/base)
        ser = Series(["a", "b", "c", "c", "c", "b"], name="xxx")
        res = ser.value_counts()
        exp = Series([3, 2, 1], name="xxx", index=["c", "b", "a"])
        tm.assert_series_equal(res, exp)

def test_value_counts_categorical_with_nan(self):
        # see GH#9443

# sanity check
        ser = Series(["a", "b", "a"], dtype="category")
        exp = Series([2, 1], index=CategoricalIndex(["a", "b"]))

res = ser.value_counts(dropna=True)
        tm.assert_series_equal(res, exp)

# same Series via two different constructions --> same behaviour
        series = [
            Series(["a", "b", None, "a", None, None], dtype="category"),
            Series(
                Categorical(["a", "b", None, "a", None, None], categories=["a", "b"])
            ),
        ]

for ser in series:
            # None is a NaN value, so we exclude its count here
            exp = Series([2, 1], index=CategoricalIndex(["a", "b"]))
            res = ser.value_counts(dropna=True)
            tm.assert_series_equal(res, exp)

# we don't exclude the count of None and sort by counts
            exp = Series([3, 2, 1], index=CategoricalIndex([np.nan, "a", "b"]))
            res = ser.value_counts(dropna=False)
            tm.assert_series_equal(res, exp)

# When we aren't sorting by counts, and np.nan isn't a
            # category, it should be last.
            exp = Series([2, 1, 3], index=CategoricalIndex(["a", "b", np.nan]))
            res = ser.value_counts(dropna=False, sort=False)
            tm.assert_series_equal(res, exp)

@pytest.mark.parametrize(
        "ser, dropna, exp",
        [
            (
                pd.Series([False, True, True, pd.NA]),
                False,
                pd.Series([2, 1, 1], index=[True, False, pd.NA]),
            ),
            (
                pd.Series([False, True, True, pd.NA]),
                True,
                pd.Series([2, 1], index=[True, False]),
            ),
            (
                pd.Series(range(3), index=[True, False, np.nan]).index,
                False,
                pd.Series([1, 1, 1], index=[True, False, pd.NA]),
            ),
        ],
    )
    def test_value_counts_bool_with_nan(self, ser, dropna, exp):
        # GH32146
        out = ser.value_counts(dropna=dropna)
        tm.assert_series_equal(out, exp)

import numpy as np import pytest import pandas as pd from pandas import Categorical, CategoricalIndex, Series import pandas._testing as tm class TestSeriesValueCounts: def test_value_counts_datetime(self): # most dtypes are tested in tests/base values = [ pd.Timestamp("2011-01-01 09:00"), pd.Timestamp("2011-01-01 10:00"), pd.Timestamp("2011-01-01 11:00"), pd.Timestamp("2011-01-01 09:00"), pd.Timestamp("2011-01-01 09:00"), pd.Timestamp("2011-01-01 11:00"), ] exp_idx = pd.DatetimeIndex( ["2011-01-01 09:00", "2011-01-01 11:00", "2011-01-01 10:00"] ) exp = pd.Series([3, 2, 1], index=exp_idx, name="xxx") ser = pd.Series(values, name="xxx") tm.assert_series_equal(ser.value_counts(), exp) # check DatetimeIndex outputs the same result idx = pd.DatetimeIndex(values, name="xxx") tm.assert_series_equal(idx.value_counts(), exp) # normalize exp = pd.Series(np.array([3.0, 2.0, 1]) / 6.0, index=exp_idx, name="xxx") tm.assert_series_equal(ser.value_counts(normalize=True), exp) tm.assert_series_equal(idx.value_counts(normalize=True), exp) def test_value_counts_datetime_tz(self): values = [ pd.Timestamp("2011-01-01 09:00", tz="US/Eastern"), pd.Timestamp("2011-01-01 10:00", tz="US/Eastern"), pd.Timestamp("2011-01-01 11:00", tz="US/Eastern"), pd.Timestamp("2011-01-01 09:00", tz="US/Eastern"), pd.Timestamp("2011-01-01 09:00", tz="US/Eastern"), pd.Timestamp("2011-01-01 11:00", tz="US/Eastern"), ] exp_idx = pd.DatetimeIndex( ["2011-01-01 09:00", "2011-01-01 11:00", "2011-01-01 10:00"], tz="US/Eastern", ) exp = pd.Series([3, 2, 1], index=exp_idx, name="xxx") ser = pd.Series(values, name="xxx") tm.assert_series_equal(ser.value_counts(), exp) idx = pd.DatetimeIndex(values, name="xxx") tm.assert_series_equal(idx.value_counts(), exp) exp = pd.Series(np.array([3.0, 2.0, 1]) / 6.0, index=exp_idx, name="xxx") tm.assert_series_equal(ser.value_counts(normalize=True), exp) tm.assert_series_equal(idx.value_counts(normalize=True), exp) def test_value_counts_period(self): values = [ pd.Period("2011-01", freq="M"), pd.Period("2011-02", freq="M"), pd.Period("2011-03", freq="M"), pd.Period("2011-01", freq="M"), pd.Period("2011-01", freq="M"), pd.Period("2011-03", freq="M"), ] exp_idx = pd.PeriodIndex(["2011-01", "2011-03", "2011-02"], freq="M") exp = pd.Series([3, 2, 1], index=exp_idx, name="xxx") ser = pd.Series(values, name="xxx") tm.assert_series_equal(ser.value_counts(), exp) # check DatetimeIndex outputs the same result idx = pd.PeriodIndex(values, name="xxx") tm.assert_series_equal(idx.value_counts(), exp) # normalize exp = pd.Series(np.array([3.0, 2.0, 1]) / 6.0, index=exp_idx, name="xxx") tm.assert_series_equal(ser.value_counts(normalize=True), exp) tm.assert_series_equal(idx.value_counts(normalize=True), exp) def test_value_counts_categorical_ordered(self): # most dtypes are tested in tests/base values = pd.Categorical([1, 2, 3, 1, 1, 3], ordered=True) exp_idx = pd.CategoricalIndex([1, 3, 2], categories=[1, 2, 3], ordered=True) exp = pd.Series([3, 2, 1], index=exp_idx, name="xxx") ser = pd.Series(values, name="xxx") tm.assert_series_equal(ser.value_counts(), exp) # check CategoricalIndex outputs the same result idx = pd.CategoricalIndex(values, name="xxx") tm.assert_series_equal(idx.value_counts(), exp) # normalize exp = pd.Series(np.array([3.0, 2.0, 1]) / 6.0, index=exp_idx, name="xxx") tm.assert_series_equal(ser.value_counts(normalize=True), exp) tm.assert_series_equal(idx.value_counts(normalize=True), exp) def test_value_counts_categorical_not_ordered(self): values = pd.Categorical([1, 2, 3, 1, 1, 3], ordered=False) exp_idx = pd.CategoricalIndex([1, 3, 2], categories=[1, 2, 3], ordered=False) exp = pd.Series([3, 2, 1], index=exp_idx, name="xxx") ser = pd.Series(values, name="xxx") tm.assert_series_equal(ser.value_counts(), exp) # check CategoricalIndex outputs the same result idx = pd.CategoricalIndex(values, name="xxx") tm.assert_series_equal(idx.value_counts(), exp) # normalize exp = pd.Series(np.array([3.0, 2.0, 1]) / 6.0, index=exp_idx, name="xxx") tm.assert_series_equal(ser.value_counts(normalize=True), exp) tm.assert_series_equal(idx.value_counts(normalize=True), exp) def test_value_counts_categorical(self): # GH#12835 cats = Categorical(list("abcccb"), categories=list("cabd")) ser = Series(cats, name="xxx") res = ser.value_counts(sort=False) exp_index = CategoricalIndex(list("cabd"), categories=cats.categories) exp = Series([3, 1, 2, 0], name="xxx", index=exp_index) tm.assert_series_equal(res, exp) res = ser.value_counts(sort=True) exp_index = CategoricalIndex(list("cbad"), categories=cats.categories) exp = Series([3, 2, 1, 0], name="xxx", index=exp_index) tm.assert_series_equal(res, exp) # check object dtype handles the Series.name as the same # (tested in tests/base) ser = Series(["a", "b", "c", "c", "c", "b"], name="xxx") res = ser.value_counts() exp = Series([3, 2, 1], name="xxx", index=["c", "b", "a"]) tm.assert_series_equal(res, exp) def test_value_counts_categorical_with_nan(self): # see GH#9443 # sanity check ser = Series(["a", "b", "a"], dtype="category") exp = Series([2, 1], index=CategoricalIndex(["a", "b"])) res = ser.value_counts(dropna=True) tm.assert_series_equal(res, exp) res = ser.value_counts(dropna=True) tm.assert_series_equal(res, exp) # same Series via two different constructions --> same behaviour series = [ Series(["a", "b", None, "a", None, None], dtype="category"), Series( Categorical(["a", "b", None, "a", None, None], categories=["a", "b"]) ), ] for ser in series: # None is a NaN value, so we exclude its count here exp = Series([2, 1], index=CategoricalIndex(["a", "b"])) res = ser.value_counts(dropna=True) tm.assert_series_equal(res, exp) # we don't exclude the count of None and sort by counts exp = Series([3, 2, 1], index=CategoricalIndex([np.nan, "a", "b"])) res = ser.value_counts(dropna=False) tm.assert_series_equal(res, exp) # When we aren't sorting by counts, and np.nan isn't a # category, it should be last. exp = Series([2, 1, 3], index=CategoricalIndex(["a", "b", np.nan])) res = ser.value_counts(dropna=False, sort=False) tm.assert_series_equal(res, exp) @pytest.mark.parametrize( "ser, dropna, exp", [ ( pd.Series([False, True, True, pd.NA]), False, pd.Series([2, 1, 1], index=[True, False, pd.NA]), ), ( pd.Series([False, True, True, pd.NA]), True, pd.Series([2, 1], index=[True, False]), ), ( pd.Series(range(3), index=[True, False, np.nan]).index, False, pd.Series([1, 1, 1], index=[True, False, pd.NA]), ), ], ) def test_value_counts_bool_with_nan(self, ser, dropna, exp): # GH32146 out = ser.value_counts(dropna=dropna) tm.assert_series_equal(out, exp)