Series.value_counts: Preserve original ordering

doc/source/whatsnew/v0.24.0.rst

@@ -385,6 +385,7 @@ Backwards incompatible API changes
 - :func:`read_csv` will now raise a ``ValueError`` if a column with missing values is declared as having dtype ``bool`` (:issue:`20591`)
 - The column order of the resultant :class:`DataFrame` from :meth:`MultiIndex.to_frame` is now guaranteed to match the :attr:`MultiIndex.names` order. (:issue:`22420`)
 - :func:`pd.offsets.generate_range` argument ``time_rule`` has been removed; use ``offset`` instead (:issue:`24157`)
+- :meth:`Series.value_counts` returns the counts in the same ordering as the original series when using ``sort=False`` (:issue:`12679`)
 
 Percentage change on groupby
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^

pandas/core/algorithms.py

@@ -667,6 +667,7 @@ def value_counts(values, sort=True, ascending=False, normalize=False,
 
     """
     from pandas.core.series import Series, Index
+    from pandas.core.dtypes.generic import ABCCategoricalIndex
     name = getattr(values, 'name', None)
 
     if bins is not None:
@@ -695,19 +696,25 @@ def value_counts(values, sort=True, ascending=False, normalize=False,
         if is_extension_array_dtype(values) or is_sparse(values):
 
             # handle Categorical and sparse,
-            result = Series(values)._values.value_counts(dropna=dropna)
+            vals = Series(values)
+            uniq = vals._values.unique()
+            result = vals._values.value_counts(dropna=dropna)
             result.name = name
             counts = result.values
 
         else:
             keys, counts = _value_counts_arraylike(values, dropna)
+            uniq = unique(values)
 
             if not isinstance(keys, Index):
                 keys = Index(keys)
             result = Series(counts, index=keys, name=name)
 
     if sort:
         result = result.sort_values(ascending=ascending)
+    elif bins is None:
+        if not isinstance(result.index, ABCCategoricalIndex):
+            result = result.reindex(uniq)
 
     if normalize:
         result = result / float(counts.sum())

pandas/tests/test_algos.py

@@ -962,6 +962,42 @@ def test_value_counts_uint64(self):
         if not compat.is_platform_32bit():
             tm.assert_series_equal(result, expected)
 
+    @pytest.mark.parametrize("sort",
+                             [pytest.param(True, marks=pytest.mark.xfail), False])
+    @pytest.mark.parametrize("ascending", [True, False])
+    def test_value_counts_single_occurance(self, sort, ascending):
+        # GH 12679
+        # All items occour exactly once.
+        # No matter if sorted or not, the resulting values should be in
+        # the same order.
+        expected = Series(list('bacdef'))
+
+        # Guarantee the same index if value_counts(sort=False) is used
+        vc = expected.value_counts(sort=sort, ascending=ascending)
+        result = Series(vc.index)
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize("ascending", [True, False])
+    def test_value_counts_nonsorted_double_occurance(self, ascending):
+        # GH 12679
+        # 'a' is there twice. Sorted, it should be there at the top.
+        s = Series(list('bacaef'))
+        expected = Series(list('bacef'))
+
+        vc = s.value_counts(sort=False, ascending=ascending)
+        result = Series(vc.index)
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize("ascending, expected",
+                             [(True, Series(list('abcef'))),
+                              (False, Series(list('bcefa')))])
+    @pytest.mark.xfail(reason="sort=True does not guarantee the same order")
+    def test_value_counts_sorted_double_occurance(self, ascending, expected):
+        # GH 12679
+        s = Series(list('bacaef'))
+        vc = s.value_counts(sort=True, ascending=ascending)
+        tm.assert_series_equal(Series(vc.index), expected)
+
 
 class TestDuplicated(object):