Added future warning on ambiguous case (GH 5677)

Author: Jon M. Mease

pandas/core/groupby.py

@@ -2450,6 +2450,13 @@ def is_in_obj(gpr):
 
         elif is_in_axis(gpr):  # df.groupby('name')
             if gpr in obj:
+                if gpr in obj.index.names:
+                    warnings.warn(
+                        ("'%s' is both a column name and an index level.\n"
+                         "Defaulting to column but "
+                         "this will raise an ambiguity error in a "
+                         "future version") % gpr,
+                        FutureWarning, stacklevel=2)
                 in_axis, name, gpr = True, gpr, obj[gpr]
                 exclusions.append(name)
             elif gpr in obj.index.names:

pandas/tests/test_groupby.py

@@ -575,7 +575,7 @@ def test_grouper_column_and_index_sugar(self):
         expected = df_single.groupby(pd.Grouper(level='inner')).mean()
         assert_frame_equal(result, expected)
 
-    def test_grouper_column_takes_precedence_over_level(self):
+    def test_grouper_column_takes_precedence_over_level_with_warning(self):
         # GH 5677, when a string passed as the `by` parameter
         # matches a column and an index level the column takes
         # precedence
@@ -592,74 +592,94 @@ def test_grouper_column_takes_precedence_over_level(self):
         df_single_both = df_multi_both.reset_index('outer')
 
         # Group MultiIndex by single key
-        result = df_multi_both.groupby('inner').mean()
-        expected = df_multi_both.groupby(pd.Grouper(key='inner')).mean()
+        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
+            result = df_multi_both.groupby('inner').mean()
+
+        expected = df_multi_both.groupby([pd.Grouper(key='inner')]).mean()
+
         assert_frame_equal(result, expected)
         not_expected = df_multi_both.groupby(pd.Grouper(level='inner')).mean()
-        assert not result.index.equals(not_expected.index)
+        self.assertFalse(result.index.equals(not_expected.index))
 
         # Group single Index by single key
-        result = df_single_both.groupby('inner').mean()
-        expected = df_single_both.groupby(pd.Grouper(key='inner')).mean()
+        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
+            result = df_single_both.groupby('inner').mean()
+
+        expected = df_single_both.groupby([pd.Grouper(key='inner')]).mean()
+
         assert_frame_equal(result, expected)
         not_expected = df_single_both.groupby(pd.Grouper(level='inner')).mean()
-        assert not result.index.equals(not_expected.index)
+        self.assertFalse(result.index.equals(not_expected.index))
 
         # Group MultiIndex by single key list
-        result = df_multi_both.groupby(['inner']).mean()
-        expected = df_multi_both.groupby(pd.Grouper(key='inner')).mean()
+        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
+            result = df_multi_both.groupby(['inner']).mean()
+
+        expected = df_multi_both.groupby([pd.Grouper(key='inner')]).mean()
+
         assert_frame_equal(result, expected)
         not_expected = df_multi_both.groupby(pd.Grouper(level='inner')).mean()
-        assert not result.index.equals(not_expected.index)
+        self.assertFalse(result.index.equals(not_expected.index))
 
         # Group single Index by single key list
-        result = df_single_both.groupby(['inner']).mean()
-        expected = df_single_both.groupby(pd.Grouper(key='inner')).mean()
+        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
+            result = df_single_both.groupby(['inner']).mean()
+
+        expected = df_single_both.groupby([pd.Grouper(key='inner')]).mean()
+
         assert_frame_equal(result, expected)
         not_expected = df_single_both.groupby(pd.Grouper(level='inner')).mean()
-        assert not result.index.equals(not_expected.index)
+        self.assertFalse(result.index.equals(not_expected.index))
 
         # Group MultiIndex by two keys (1)
-        result = df_multi_both.groupby(['B', 'inner']).mean()
+        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
+            result = df_multi_both.groupby(['B', 'inner']).mean()
+
         expected = df_multi_both.groupby(['B',
-                                          pd.Grouper(key='inner')]).mean()
+                                              pd.Grouper(key='inner')]).mean()
         assert_frame_equal(result, expected)
 
         not_expected = df_multi_both.groupby(['B',
                                               pd.Grouper(level='inner')
                                               ]).mean()
-        assert not result.index.equals(not_expected.index)
+        self.assertFalse(result.index.equals(not_expected.index))
 
         # Group MultiIndex by two keys (2)
-        result = df_multi_both.groupby(['inner', 'B']).mean()
+        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
+            result = df_multi_both.groupby(['inner', 'B']).mean()
+
         expected = df_multi_both.groupby([pd.Grouper(key='inner'),
                                           'B']).mean()
         assert_frame_equal(result, expected)
 
         not_expected = df_multi_both.groupby([pd.Grouper(level='inner'),
                                               'B']).mean()
-        assert not result.index.equals(not_expected.index)
+        self.assertFalse(result.index.equals(not_expected.index))
 
         # Group single Index by two keys (1)
-        result = df_single_both.groupby(['B', 'inner']).mean()
+        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
+            result = df_single_both.groupby(['B', 'inner']).mean()
+
         expected = df_single_both.groupby(['B',
-                                          pd.Grouper(key='inner')]).mean()
+                                           pd.Grouper(key='inner')]).mean()
         assert_frame_equal(result, expected)
 
         not_expected = df_single_both.groupby(['B',
                                                pd.Grouper(level='inner')
                                                ]).mean()
-        assert not result.index.equals(not_expected.index)
+        self.assertFalse(result.index.equals(not_expected.index))
 
         # Group single Index by two keys (2)
-        result = df_single_both.groupby(['inner', 'B']).mean()
+        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
+            result = df_single_both.groupby(['inner', 'B']).mean()
+
         expected = df_single_both.groupby([pd.Grouper(key='inner'),
                                            'B']).mean()
         assert_frame_equal(result, expected)
 
         not_expected = df_single_both.groupby([pd.Grouper(level='inner'),
                                                'B']).mean()
-        assert not result.index.equals(not_expected.index)
+        self.assertFalse(result.index.equals(not_expected.index))
 
     def test_grouper_getting_correct_binner(self):