fix insert, delete

Author: jreback

pandas/core/index.py

@@ -2559,12 +2559,17 @@ def create_categorical(data=data, categories=categories):
 
         if isinstance(data, com.ABCCategorical):
             data = create_categorical(data, categories)
-        elif data is None or np.isscalar(data):
-            cls._scalar_data_error(data)
         elif isinstance(data, CategoricalIndex):
             data = data._data
             data = create_categorical(data, categories)
         else:
+
+            # don't allow scalars
+            # if data is None, then categories must be provided
+            if lib.isscalar(data):
+                if data is not None or categories is None:
+                    cls._scalar_data_error(data)
+                data = []
             from pandas.core.categorical import Categorical
             data = Categorical(data, categories=categories, ordered=True)
 
@@ -2718,6 +2723,48 @@ def get_indexer(self, target, method=None, limit=None):
 
         return com._ensure_platform_int(indexer)
 
+    def delete(self, loc):
+        """
+        Make new Index with passed location(-s) deleted
+
+        Returns
+        -------
+        new_index : Index
+        """
+        from pandas import Categorical
+        cat = Categorical.from_codes(np.delete(self.codes, loc), categories=self.categories)
+        return CategoricalIndex(cat, name=self.name)
+
+    def insert(self, loc, item):
+        """
+        Make new Index inserting new item at location. Follows
+        Python list.append semantics for negative values
+
+        Parameters
+        ----------
+        loc : int
+        item : object
+
+        Returns
+        -------
+        new_index : Index
+
+        Raises
+        ------
+        ValueError if the item is not in the categories
+
+        """
+        code = self.categories.get_indexer([item])
+        if (code == -1):
+            raise ValueError("cannot insert a non-category item to a CategoricalIndex")
+
+        from pandas import Categorical
+        codes = self.codes
+        idx = np.concatenate(
+            (codes[:loc], code, codes[loc:]))
+        cat = Categorical.from_codes(idx, categories=self.categories)
+        return CategoricalIndex(cat, name=self.name)
+
 
 CategoricalIndex._add_numeric_methods_disabled()
 CategoricalIndex._add_logical_methods_disabled()

pandas/tests/test_categorical.py

@@ -2506,6 +2506,8 @@ def f():
         dfx['grade'].cat.categories
         self.assert_numpy_array_equal(df['grade'].cat.categories, dfx['grade'].cat.categories)
 
+    def test_concat_preserve(self):
+
         # GH 8641
         # series concat not preserving category dtype
         s = Series(list('abc'),dtype='category')
@@ -2523,6 +2525,24 @@ def f():
         expected = Series(list('abcabc'),index=[0,1,2,0,1,2]).astype('category')
         tm.assert_series_equal(result, expected)
 
+        a = Series(np.arange(6,dtype='int64'))
+        b = Series(list('aabbca'))
+
+        df2 = DataFrame({'A' : a, 'B' : b.astype('category',categories=list('cab')) })
+        result = pd.concat([df2,df2])
+        expected = DataFrame({'A' : pd.concat([a,a]), 'B' : pd.concat([b,b]).astype('category',categories=list('cab')) })
+        tm.assert_frame_equal(result, expected)
+
+    def test_categorical_index_preserver(self):
+
+        a = Series(np.arange(6,dtype='int64'))
+        b = Series(list('aabbca'))
+
+        df2 = DataFrame({'A' : a, 'B' : b.astype('category',categories=list('cab')) }).set_index('B')
+        result = pd.concat([df2,df2])
+        expected = DataFrame({'A' : pd.concat([a,a]), 'B' : pd.concat([b,b]).astype('category',categories=list('cab')) }).set_index('B')
+        tm.assert_frame_equal(result, expected)
+
     def test_append(self):
         cat = pd.Categorical(["a","b"], categories=["a","b"])
         vals = [1,2]

pandas/tests/test_frame.py

@@ -10699,12 +10699,10 @@ def test_indexing_categorical_index(self):
 
         # value not in the categories
         self.assertRaises(KeyError, lambda : df.loc['d'])
+        def f():
+            df.loc['d'] = 10
 
-        df.loc['d'] = 10
-        expected = DataFrame({'A' : [20,20,2,3,4,20,10],
-                              'B' : Series(list('aabbcad'))}).set_index('B')
-        expected.index.name = None
-        assert_frame_equal(df, expected)
+        self.assertRaises(ValueError, f)
 
     def test_sort_nan(self):
         # GH3917

pandas/tests/test_index.py

@@ -1329,6 +1329,8 @@ def create_index(self):
         return CategoricalIndex(list('aabbcdefg'))
 
     def test_construction(self):
+
+        categories = list('abcd')
         idx = self.create_index()
 
         result = Index(idx)
@@ -1337,23 +1339,28 @@ def test_construction(self):
         result = Index(idx.values)
         self.assertTrue(result.equals(idx))
 
+        # empty
+        result = CategoricalIndex(categories=categories)
+        self.assertTrue(result.categories.equals(Index(categories)))
+        self.assert_numpy_array_equal(result.codes,np.array([],dtype='int8'))
+
         # passing categories
-        result = CategoricalIndex(list('aabbca'),categories=list('abcd'))
-        self.assertTrue(result.categories.equals(Index(list('abcd'))))
+        result = CategoricalIndex(list('aabbca'),categories=categories)
+        self.assertTrue(result.categories.equals(Index(categories)))
         self.assert_numpy_array_equal(result.codes,np.array([0,0,1,1,2,0],dtype='int8'))
 
         c = pd.Categorical(list('aabbca'))
         result = CategoricalIndex(c)
         self.assertTrue(result.categories.equals(Index(list('abc'))))
         self.assert_numpy_array_equal(result.codes,np.array([0,0,1,1,2,0],dtype='int8'))
 
-        result = CategoricalIndex(c,categories=list('abcd'))
-        self.assertTrue(result.categories.equals(Index(list('abcd'))))
+        result = CategoricalIndex(c,categories=categories)
+        self.assertTrue(result.categories.equals(Index(categories)))
         self.assert_numpy_array_equal(result.codes,np.array([0,0,1,1,2,0],dtype='int8'))
 
         ci = CategoricalIndex(c,categories=list('abcd'))
         result = CategoricalIndex(ci)
-        self.assertTrue(result.categories.equals(Index(list('abcd'))))
+        self.assertTrue(result.categories.equals(Index(categories)))
         self.assert_numpy_array_equal(result.codes,np.array([0,0,1,1,2,0],dtype='int8'))
 
         result = CategoricalIndex(ci, categories=list('ab'))
@@ -1368,6 +1375,74 @@ def test_construction(self):
         self.assertIsInstance(result, Index)
         self.assertNotIsInstance(result, CategoricalIndex)
 
+    def test_append(self):
+
+        categories = list('cab')
+        ci = CategoricalIndex(list('aabbca'), categories=categories)
+
+        # append cats with the same categories
+        result = ci[:3].append(ci[3:])
+        self.assertTrue(result.equals(ci))
+
+        foos = [ci[:1], ci[1:3], ci[3:]]
+        result = foos[0].append(foos[1:])
+        self.assertTrue(result.equals(ci))
+
+        # empty
+        result = ci.append([])
+        self.assertTrue(result.equals(ci))
+
+        # appending with different categories
+        self.assertRaises(ValueError, lambda : ci.append(ci.values.reorder_categories(list('abc'))))
+
+        # with objects
+        result = ci.append(['c','a'])
+        expected = CategoricalIndex(list('aabbcaca'), categories=categories)
+        self.assertTrue(result.equals(expected))
+
+        # invalid objects
+        self.assertRaises(ValueError, lambda : ci.append(['a','d']))
+
+    def test_insert(self):
+
+        categories = list('cab')
+        ci = CategoricalIndex(list('aabbca'), categories=categories)
+
+        #test 0th element
+        result = ci.insert(0, 'a')
+        expected = CategoricalIndex(list('aaabbca'),categories=categories)
+        self.assertTrue(result.equals(expected))
+
+        #test Nth element that follows Python list behavior
+        result = ci.insert(-1, 'a')
+        expected = CategoricalIndex(list('aabbcaa'),categories=categories)
+        self.assertTrue(result.equals(expected))
+
+        #test empty
+        result = CategoricalIndex(categories=categories).insert(0, 'a')
+        expected = CategoricalIndex(['a'],categories=categories)
+        self.assertTrue(result.equals(expected))
+
+        # invalid
+        self.assertRaises(ValueError, lambda : ci.insert(0,'d'))
+
+    def test_delete(self):
+
+        categories = list('cab')
+        ci = CategoricalIndex(list('aabbca'), categories=categories)
+
+        result = ci.delete(0)
+        expected = CategoricalIndex(list('abbca'),categories=categories)
+        self.assertTrue(result.equals(expected))
+
+        result = ci.delete(-1)
+        expected = CategoricalIndex(list('aabbc'),categories=categories)
+        self.assertTrue(result.equals(expected))
+
+        with tm.assertRaises((IndexError, ValueError)):
+            # either depeidnig on numpy version
+            result = ci.delete(10)
+
     def test_astype(self):
 
         idx = self.create_index()