FIX: interesction and union correct name chaning behavior. fixes #9943 partly #9862

Author: hsperr

doc/source/whatsnew/v0.16.1.txt

@@ -244,3 +244,13 @@ Bug Fixes
 
 
 - Bug in hiding ticklabels with subplots and shared axes when adding a new plot to an existing grid of axes (:issue:`9158`)
+
+
+
+
+
+
+
+
+
+- ``Union`` and ``intersection`` now wont change index name. (:issue:`9943`)

pandas/core/index.py

@@ -1219,14 +1219,26 @@ def union(self, other):
         if len(other) == 0 or self.equals(other):
             return self
 
+        keep_name = True
+        #GH 9943, 9862 added keep_name
+        if hasattr(other, 'name'):
+            if other.name != self.name and not other.name is None:
+                keep_name = False
+
+        other = _ensure_index(other)
+
         if len(self) == 0:
-            return _ensure_index(other)
+            return other
 
         self._assert_can_do_setop(other)
 
         if not is_dtype_equal(self.dtype,other.dtype):
             this = self.astype('O')
             other = other.astype('O')
+
+            if keep_name:
+                other.name=self.name
+
             return this.union(other)
 
         if self.is_monotonic and other.is_monotonic:
@@ -1268,11 +1280,14 @@ def union(self, other):
                     warnings.warn("%s, sort order is undefined for "
                                   "incomparable objects" % e, RuntimeWarning)
 
+        if keep_name:
+            other.name = self.name
+
         # for subclasses
         return self._wrap_union_result(other, result)
 
     def _wrap_union_result(self, other, result):
-        name = self.name if self.name == other.name else None
+        name = self.name if other.name == self.name or other.name==None else None
         return self.__class__(data=result, name=name)
 
     def intersection(self, other):
@@ -1293,6 +1308,12 @@ def intersection(self, other):
 
         self._assert_can_do_setop(other)
 
+        keep_name = True
+        #GH 9943, 9862 added keep_name
+        if hasattr(other, 'name'):
+            if not (other.name == self.name or other.name is None):
+                keep_name = False
+
         other = _ensure_index(other)
 
         if self.equals(other):
@@ -1306,6 +1327,10 @@ def intersection(self, other):
         if self.is_monotonic and other.is_monotonic:
             try:
                 result = self._inner_indexer(self.values, other.values)[0]
+
+                if keep_name:
+                    other.name = self.name
+
                 return self._wrap_union_result(other, result)
             except TypeError:
                 pass
@@ -1319,8 +1344,10 @@ def intersection(self, other):
             indexer = indexer[indexer != -1]
 
         taken = self.take(indexer)
-        if self.name != other.name:
+
+        if not keep_name:
             taken.name = None
+
         return taken
 
     def difference(self, other):
@@ -5324,7 +5351,9 @@ def union(self, other):
         if len(other) == 0 or self.equals(other):
             return self
 
-        result_names = self.names if self.names == other.names else None
+        result_names =  None
+        if self.names == other.names or other.names is None:
+            result_names = self.names
 
         uniq_tuples = lib.fast_unique_multiple([self.values, other.values])
         return MultiIndex.from_arrays(lzip(*uniq_tuples), sortorder=0,
@@ -5347,7 +5376,9 @@ def intersection(self, other):
         if self.equals(other):
             return self
 
-        result_names = self.names if self.names == other.names else None
+        result_names = None
+        if self.names == other.names or other.name is None:
+            result_names = self.names
 
         self_tuples = self.values
         other_tuples = other.values
@@ -5380,7 +5411,9 @@ def difference(self, other):
                                 ' tuples')
             result_names = self.names
         else:
-            result_names = self.names if self.names == other.names else None
+            result_names = None
+            if self.names == other.names or other.names == None:
+                result_names = self.names
 
         if self.equals(other):
             return MultiIndex(levels=[[]] * self.nlevels,
@@ -5475,7 +5508,9 @@ def _bounds(self):
         return self.__bounds
 
     def _wrap_joined_index(self, joined, other):
-        names = self.names if self.names == other.names else None
+        names = None
+        if self.names == other.names or other.names == None:
+            names = self.names
         return MultiIndex.from_tuples(joined, names=names)
 
     @Appender(Index.isin.__doc__)

pandas/tests/test_index.py

@@ -17,7 +17,7 @@
                     CategoricalIndex, DatetimeIndex, TimedeltaIndex, PeriodIndex)
 from pandas.core.index import InvalidIndexError, NumericIndex
 from pandas.util.testing import (assert_almost_equal, assertRaisesRegexp,
-                                 assert_copy)
+                                 assert_copy, assert_frame_equal)
 from pandas import compat
 from pandas.compat import long
 
@@ -603,6 +603,157 @@ def test_shift(self):
         shifted.name = 'shifted'
         self.assertEqual(shifted.name, shifted.shift(1, 'D').name)
 
+    def test_union_naming_behavior(self):
+        #9965
+        idx_name_a = pd.Index([1,2,3], name='a')
+        idx_name_b = pd.Index([4,5,6], name='b')
+        idx2_name_a = pd.Index([2,9,8], name='a')
+
+        stridx_name_stra = pd.Index(['1','2'], name='stra')
+        stridx_name_a = pd.Index(['1','2'], name='a')
+
+        idx_name_none = pd.Index(['1','2'], name=None)
+
+        dateindex_name_a = pd.DatetimeIndex([datetime.today()], name='a')
+        dateindex_name_b = pd.DatetimeIndex([datetime.today()], name='b')
+        dateindex_name_None = pd.DatetimeIndex([datetime.today()], name=None)
+
+        python_array = [1,2,3]
+        numpy_array = np.array([1,2,3])
+
+        #index union index naming behavior
+        self.assertEqual(idx_name_a.union(idx_name_b).name, None)
+        self.assertEqual(idx_name_a.union(idx2_name_a).name, 'a')
+
+        #index union array
+        self.assertEqual(idx_name_a.union(python_array).name, 'a')
+        self.assertEqual(idx_name_a.union(numpy_array).name, 'a')
+
+        #index union index different dtype
+        self.assertEqual(idx_name_a.union(stridx_name_a).name, 'a')
+        self.assertEqual(idx_name_a.union(stridx_name_stra).name, None)
+
+        #index union index with no name
+        self.assertEqual(idx_name_a.union(idx_name_none).name, 'a')
+
+        #index union dateindex
+        self.assertEqual(idx_name_a.union(dateindex_name_a).name, 'a')
+        self.assertEqual(idx_name_a.union(dateindex_name_b).name, None)
+        self.assertEqual(idx_name_a.union(dateindex_name_None).name, 'a')
+
+        #dateindex union
+        self.assertEqual(dateindex_name_a.union(python_array).name, 'a')
+        self.assertEqual(dateindex_name_a.union(numpy_array).name, 'a')
+
+        self.assertEqual(dateindex_name_a.union(idx_name_none).name, 'a')
+        self.assertEqual(dateindex_name_a.union(dateindex_name_b).name, None)
+        self.assertEqual(dateindex_name_a.union(dateindex_name_None).name, 'a')
+        self.assertEqual(dateindex_name_a.union(idx_name_a).name, 'a')
+
+    def test_intersection_naming_behavior(self):
+        #9965
+        idx_name_a = pd.Index([1,2,3], name='a')
+        idx_name_b = pd.Index([4,5,6], name='b')
+        idx2_name_a = pd.Index([2,9,8], name='a')
+
+        stridx_name_stra = pd.Index(['1','2'], name='stra')
+        stridx_name_a = pd.Index(['1','2'], name='a')
+
+        idx_name_none = pd.Index(['1','2'], name=None)
+
+        dateindex_name_a = pd.DatetimeIndex([datetime.today()], name='a')
+        dateindex_name_b = pd.DatetimeIndex([datetime.today()], name='b')
+        dateindex_name_None = pd.DatetimeIndex([datetime.today()], name=None)
+
+        python_array = [1,2,3]
+        numpy_array = np.array([1,2,3])
+
+        #index intersection index naming behavior
+        self.assertEqual(idx_name_a.intersection(idx_name_b).name, None)
+        self.assertEqual(idx_name_a.intersection(idx2_name_a).name, 'a')
+
+        #index intersection array
+        self.assertEqual(idx_name_a.intersection(python_array).name, 'a')
+        self.assertEqual(idx_name_a.intersection(numpy_array).name, 'a')
+
+        #index intersection index different dtype
+        self.assertEqual(idx_name_a.intersection(stridx_name_a).name, 'a')
+        self.assertEqual(idx_name_a.intersection(stridx_name_stra).name, None)
+
+        #index intersection index with no name
+        self.assertEqual(idx_name_a.intersection(idx_name_none).name, 'a')
+
+        #index intersection dateindex
+        self.assertEqual(idx_name_a.intersection(dateindex_name_a).name, 'a')
+        self.assertEqual(idx_name_a.intersection(dateindex_name_b).name, None)
+        self.assertEqual(idx_name_a.intersection(dateindex_name_None).name, 'a')
+
+        #dateindex intersection
+        self.assertEqual(dateindex_name_a.intersection(python_array).name, 'a')
+        self.assertEqual(dateindex_name_a.intersection(numpy_array).name, 'a')
+
+        self.assertEqual(dateindex_name_a.intersection(idx_name_none).name, 'a')
+        self.assertEqual(dateindex_name_a.intersection(dateindex_name_b).name, None)
+        self.assertEqual(dateindex_name_a.intersection(dateindex_name_None).name, 'a')
+        self.assertEqual(dateindex_name_a.intersection(idx_name_a).name, 'a')
+
+    def test_append_naming_behavior(self):
+        #9965
+        idx_name_a = pd.Index([1,2,3], name='a')
+        idx_name_b = pd.Index([4,5,6], name='b')
+        idx2_name_a = pd.Index([2,9,8], name='a')
+
+        stridx_name_stra = pd.Index(['1','2'], name='stra')
+        stridx_name_a = pd.Index(['1','2'], name='a')
+
+        idx_name_none = pd.Index(['1','2'], name=None)
+
+        dateindex_name_a = pd.DatetimeIndex([datetime.today()], name='a')
+        dateindex_name_b = pd.DatetimeIndex([datetime.today()], name='b')
+        dateindex_name_None = pd.DatetimeIndex([datetime.today()], name=None)
+
+        python_array = [1,2,3]
+        python_array_transposed = [[1],[2],[3]]
+        numpy_array = np.array([1,2,3])
+
+        #index append index naming behavior
+        self.assertEqual(idx_name_a.append(idx_name_b).name, None)
+        self.assertEqual(idx_name_a.append(idx2_name_a).name, 'a')
+
+        #index append array
+        self.assertEqual(idx_name_a.append(python_array_transposed).name, 'a')
+        self.assertEqual(idx_name_a.append(numpy_array.T).name, 'a')
+
+        #index append index different dtype
+        self.assertEqual(idx_name_a.append(stridx_name_a).name, 'a')
+        self.assertEqual(idx_name_a.append(stridx_name_stra).name, None)
+
+        #index append index with no name
+        self.assertEqual(idx_name_a.append(idx_name_none).name, 'a')
+
+        #index append dateindex
+        self.assertEqual(idx_name_a.append(dateindex_name_a).name, 'a')
+        self.assertEqual(idx_name_a.append(dateindex_name_b).name, None)
+        self.assertEqual(idx_name_a.append(dateindex_name_None).name, 'a')
+
+        #dateindex append
+        self.assertEqual(dateindex_name_a.append(python_array_transposed).name, 'a')
+        self.assertEqual(dateindex_name_a.append(numpy_array.T).name, 'a')
+
+        self.assertEqual(dateindex_name_a.append(idx_name_none).name, 'a')
+        self.assertEqual(dateindex_name_a.append(dateindex_name_b).name, None)
+        self.assertEqual(dateindex_name_a.append(dateindex_name_None).name, 'a')
+        self.assertEqual(dateindex_name_a.append(idx_name_a).name, 'a')
+
+    def test_intersection_preserves_name(self):
+        #GH 9943
+        df = pd.DataFrame([np.nan, np.nan], columns = ['tags'], index=pd.Int64Index([4815961, 4815962], dtype='int64', name='id'))
+        self.assertEqual(str(df), '         tags\nid           \n4815961   NaN\n4815962   NaN')
+        L = [4815962]
+        self.assertEqual(list(L), list(df.index.intersection(L)))
+        self.assertEqual( df.ix[L].tags.index.name, df.ix[df.index.intersection(L)].tags.index.name)
+        assert_frame_equal(df.ix[L], df.ix[df.index.intersection(L)])
+
     def test_intersection(self):
         first = self.strIndex[:20]
         second = self.strIndex[:10]
@@ -679,7 +830,13 @@ def test_union(self):
 
         second.name = 'B'
         union = first.union(second)
-        self.assertIsNone(union.name)
+        self.assertEqual(None, union.name)
+
+        #union array-like
+        print first
+        print first.name
+        union = first.union([1234])
+        self.assertEqual('A', union.name)
 
     def test_add(self):
 

pandas/tseries/index.py

@@ -879,7 +879,10 @@ def append(self, other):
             to_concat.append(other)
 
         for obj in to_concat:
-            if isinstance(obj, Index) and obj.name != name:
+            if (isinstance(obj, Index) and
+                obj.name != name and
+                obj.name is not None):
+
                 name = None
                 break
 
@@ -1026,7 +1029,7 @@ def __iter__(self):
                 yield v
 
     def _wrap_union_result(self, other, result):
-        name = self.name if self.name == other.name else None
+        name = self.name if self.name == other.name or other.name == None else None
         if self.tz != other.tz:
             raise ValueError('Passed item and index have different timezone')
         return self._simple_new(result, name=name, freq=None, tz=self.tz)