Use _shallow_copy(). Fix issue in Index.difference. Make tests try variety of index types.

Author: Dr-Irv

doc/source/whatsnew/v0.23.0.txt

@@ -837,7 +837,8 @@ Indexing
 - Bug in :func:`IntervalIndex.symmetric_difference` where the symmetric difference with a non-``IntervalIndex`` did not raise (:issue:`18475`)
 - Bug in :class:`IntervalIndex` where set operations that returned an empty ``IntervalIndex`` had the wrong dtype (:issue:`19101`)
 - Bug in :meth:`DataFrame.drop_duplicates` where no ``KeyError`` is raised when passing in columns that don't exist on the ``DataFrame`` (issue:`19726`)
-- Bug in :func:`Index.union` where resulting names were not computed correctly for certain cases (:issue:`9943`, :issue:`9862`)
+- Bug in :func:`Index.union` and :func:`Index.intersection` where name of the `Index` of the result was not computed correctly for certain cases (:issue:`9943`, :issue:`9862`)
+- Bug in :func:`Index.difference` when taking difference of set and itself as type was not preserved.
 
 
 MultiIndex

pandas/core/indexes/base.py

@@ -1240,9 +1240,9 @@ def set_names(self, names, level=None, inplace=False):
         Examples
         --------
         >>> Index([1, 2, 3, 4]).set_names('foo')
-        Int64Index([1, 2, 3, 4], dtype='int64')
+        Int64Index([1, 2, 3, 4], dtype='int64', name='foo')
         >>> Index([1, 2, 3, 4]).set_names(['foo'])
-        Int64Index([1, 2, 3, 4], dtype='int64')
+        Int64Index([1, 2, 3, 4], dtype='int64', name='foo')
         >>> idx = MultiIndex.from_tuples([(1, u'one'), (1, u'two'),
                                           (2, u'one'), (2, u'two')],
                                           names=['foo', 'bar'])
@@ -2263,17 +2263,37 @@ def __or__(self, other):
     def __xor__(self, other):
         return self.symmetric_difference(other)
 
-    def _get_setop_name_object(self, other):
+    def _get_reconciled_name_object(self, other):
         """
-        Given 2 indexes, give a setop name and object, meaning
-        we use get_op_result_name to return the name, and then
-        return a new object if we are resetting the name
+        If the result of a set operation will be self,
+        return self, unless the name changes, in which
+        case make a shallow copy of self.
         """
         name = get_op_result_name(self, other)
         if self.name != name:
             return self._shallow_copy(name=name)
         return self
 
+    def _union_corner_case(self, other):
+        """
+        If self or other have no length, or self and other
+        are the same, then return self, after reconciling names
+
+        Returns
+        -------
+        Tuple of (is_corner, result), where is_corner is True if
+        it is a corner case, and result is the reconciled result
+
+        """
+        # GH 9943 9862
+        if len(other) == 0 or self.equals(other):
+            return (True, self._get_reconciled_name_object(other))
+
+        if len(self) == 0:
+            return (True, other._get_reconciled_name_object(self))
+
+        return (False, None)
+
     def union(self, other):
         """
         Form the union of two Index objects and sorts if possible.
@@ -2298,11 +2318,9 @@ def union(self, other):
         self._assert_can_do_setop(other)
         other = _ensure_index(other)
 
-        if len(other) == 0 or self.equals(other):
-            return self._get_setop_name_object(other)
-
-        if len(self) == 0:
-            return other._get_setop_name_object(self)
+        is_corner_case, corner_result = self._union_corner_case(other)
+        if is_corner_case:
+            return corner_result
 
         # TODO: is_dtype_union_equal is a hack around
         # 1. buggy set ops with duplicates (GH #13432)
@@ -2398,7 +2416,7 @@ def intersection(self, other):
         other = _ensure_index(other)
 
         if self.equals(other):
-            return self._get_setop_name_object(other)
+            return self._get_reconciled_name_object(other)
 
         if not is_dtype_equal(self.dtype, other.dtype):
             this = self.astype('O')
@@ -2436,6 +2454,13 @@ def intersection(self, other):
             taken.name = None
         return taken
 
+    def _create_empty_index(self, name):
+        """
+        Returns an empty index.  Overridden as necessary by
+        subclasses that have different constructors.
+        """
+        return self.__class__([], name=name)
+
     def difference(self, other):
         """
         Return a new Index with elements from the index that are not in
@@ -2464,7 +2489,7 @@ def difference(self, other):
         self._assert_can_do_setop(other)
 
         if self.equals(other):
-            return Index([], name=self.name)
+            return self._create_empty_index(get_op_result_name(self, other))
 
         other, result_name = self._convert_can_do_setop(other)
 

pandas/core/indexes/category.py

@@ -25,6 +25,7 @@
 import pandas.core.base as base
 import pandas.core.missing as missing
 import pandas.core.indexes.base as ibase
+from pandas.core.ops import get_op_result_name
 
 _index_doc_kwargs = dict(ibase._index_doc_kwargs)
 _index_doc_kwargs.update(dict(target_klass='CategoricalIndex'))
@@ -300,6 +301,12 @@ def itemsize(self):
         # Size of the items in categories, not codes.
         return self.values.itemsize
 
+    def _wrap_setop_result(self, other, result):
+        name = get_op_result_name(self, other)
+        return self._simple_new(result, name=name,
+                                categories=self.categories,
+                                ordered=self.ordered)
+
     def get_values(self):
         """ return the underlying data as an ndarray """
         return self._data.get_values()
@@ -716,6 +723,13 @@ def insert(self, loc, item):
         codes = np.concatenate((codes[:loc], code, codes[loc:]))
         return self._create_from_codes(codes)
 
+    def _create_empty_index(self, name):
+        """
+        Returns an empty index using categories and ordered of self
+        """
+        return CategoricalIndex([], categories=self.categories,
+                                ordered=self.ordered, name=name)
+
     def _concat(self, to_concat, name):
         # if calling index is category, don't check dtype of others
         return CategoricalIndex._concat_same_dtype(self, to_concat, name)

pandas/core/indexes/datetimes.py

@@ -1137,6 +1137,11 @@ def union(self, other):
         y : Index or DatetimeIndex
         """
         self._assert_can_do_setop(other)
+
+        is_corner_case, corner_result = self._union_corner_case(other)
+        if is_corner_case:
+            return corner_result
+
         if not isinstance(other, DatetimeIndex):
             try:
                 other = DatetimeIndex(other)
@@ -1354,6 +1359,10 @@ def intersection(self, other):
         y : Index or DatetimeIndex
         """
         self._assert_can_do_setop(other)
+
+        if self.equals(other):
+            return self._get_reconciled_name_object(other)
+
         if not isinstance(other, DatetimeIndex):
             try:
                 other = DatetimeIndex(other)

pandas/core/indexes/multi.py

@@ -2733,7 +2733,7 @@ def intersection(self, other):
         other_tuples = other._ndarray_values
         uniq_tuples = sorted(set(self_tuples) & set(other_tuples))
         if len(uniq_tuples) == 0:
-            return MultiIndex(levels=[[]] * self.nlevels,
+            return MultiIndex(levels=self.levels,
                               labels=[[]] * self.nlevels,
                               names=result_names, verify_integrity=False)
         else:
@@ -2755,7 +2755,7 @@ def difference(self, other):
             return self
 
         if self.equals(other):
-            return MultiIndex(levels=[[]] * self.nlevels,
+            return MultiIndex(levels=self.levels,
                               labels=[[]] * self.nlevels,
                               names=result_names, verify_integrity=False)
 

pandas/core/indexes/period.py

@@ -963,6 +963,12 @@ def _convert_tolerance(self, tolerance, target):
                              'target index size')
         return self._maybe_convert_timedelta(tolerance)
 
+    def _create_empty_index(self, name):
+        """
+        Returns an empty index using freq of self
+        """
+        return PeriodIndex([], freq=self.freq, name=name)
+
     def insert(self, loc, item):
         if not isinstance(item, Period) or self.freq != item.freq:
             return self.astype(object).insert(loc, item)

pandas/core/indexes/range.py

@@ -256,7 +256,8 @@ def tolist(self):
     @Appender(_index_shared_docs['_shallow_copy'])
     def _shallow_copy(self, values=None, **kwargs):
         if values is None:
-            return RangeIndex(name=self.name, fastpath=True,
+            name = kwargs.get("name", self.name)
+            return RangeIndex(name=name, fastpath=True,
                               **dict(self._get_data_as_items()))
         else:
             kwargs.setdefault('name', self.name)
@@ -337,6 +338,10 @@ def intersection(self, other):
         -------
         intersection : Index
         """
+
+        if self.equals(other):
+            return self._get_reconciled_name_object(other)
+
         if not isinstance(other, RangeIndex):
             return super(RangeIndex, self).intersection(other)
 
@@ -417,10 +422,10 @@ def union(self, other):
         union : Index
         """
         self._assert_can_do_setop(other)
-        if len(other) == 0 or self.equals(other):
-            return self
-        if len(self) == 0:
-            return other
+        is_corner_case, corner_result = self._union_corner_case(other)
+        if is_corner_case:
+            return corner_result
+
         if isinstance(other, RangeIndex):
             start_s, step_s = self._start, self._step
             end_s = self._start + self._step * (len(self) - 1)
@@ -474,6 +479,12 @@ def join(self, other, how='left', level=None, return_indexers=False,
     def _concat_same_dtype(self, indexes, name):
         return _concat._concat_rangeindex_same_dtype(indexes).rename(name)
 
+    def _create_empty_index(self, name):
+        """
+        Returns an empty index using step size of self
+        """
+        return RangeIndex(start=None, stop=None, step=self._step, name=name)
+
     def __len__(self):
         """
         return the length of the RangeIndex

pandas/core/indexes/timedeltas.py

@@ -546,6 +546,11 @@ def union(self, other):
         y : Index or TimedeltaIndex
         """
         self._assert_can_do_setop(other)
+
+        is_corner_case, corner_result = self._union_corner_case(other)
+        if is_corner_case:
+            return corner_result
+
         if not isinstance(other, TimedeltaIndex):
             try:
                 other = TimedeltaIndex(other)
@@ -638,10 +643,6 @@ def _fast_union(self, other):
         else:
             return left
 
-    def _wrap_setop_result(self, other, result):
-        name = get_op_result_name(self, other)
-        return self._simple_new(result, name=name, freq=None)
-
     def intersection(self, other):
         """
         Specialized intersection for TimedeltaIndex objects. May be much faster
@@ -656,6 +657,10 @@ def intersection(self, other):
         y : Index or TimedeltaIndex
         """
         self._assert_can_do_setop(other)
+
+        if self.equals(other):
+            return self._get_reconciled_name_object(other)
+
         if not isinstance(other, TimedeltaIndex):
             try:
                 other = TimedeltaIndex(other)