Address requested changes

Author: Albert Villanova del Moral

pandas/core/frame.py

@@ -4463,16 +4463,15 @@ def join(self, other, on=None, how='left', lsuffix='', rsuffix='',
             * left: use calling frame's index (or column if on is specified)
             * right: use other frame's index
             * outer: form union of calling frame's index (or column if on is
-                specified) with other frame's index
+                specified) with other frame's index, and sort it
             * inner: form intersection of calling frame's index (or column if
                 on is specified) with other frame's index
         lsuffix : string
             Suffix to use from left frame's overlapping columns
         rsuffix : string
             Suffix to use from right frame's overlapping columns
         sort : boolean, default False
-            Order result DataFrame lexicographically by the join key. If False,
-            preserves the index order of the calling (left) DataFrame
+            Order result DataFrame lexicographically by the join key
 
         Notes
         -----

pandas/indexes/base.py

@@ -2089,8 +2089,8 @@ def intersection(self, other):
         """
         Form the intersection of two Index objects.
 
-        This returns a new Index with elements common to the index and `other`.
-        Sortedness of the result is not guaranteed.
+        This returns a new Index with elements common to the index and `other`,
+        preserving the calling index order.
 
         Parameters
         ----------

pandas/tests/frame/test_join.py

@@ -0,0 +1,113 @@
+# -*- coding: utf-8 -*-
+
+from __future__ import print_function
+
+from datetime import datetime
+
+import numpy as np
+from numpy import nan
+
+import pandas as pd
+
+from pandas import DataFrame, Index, Series, Timestamp, date_range
+from pandas.compat import lrange
+
+from pandas.tests.frame.common import TestData
+
+import pandas.util.testing as tm
+from pandas.util.testing import (assertRaisesRegexp,
+                                 assert_frame_equal,
+                                 assert_series_equal)
+
+
+class TestDataFrameJoin(tm.TestCase, TestData):
+
+    def test_join(self):
+        df1 = pd.DataFrame({'a': [20, 10, 0]}, index=[2, 1, 0])
+        df2 = pd.DataFrame({'b': [100, 200, 300]}, index=[1, 2, 3])
+
+        result = df1.join(df2, how='inner')
+        expected = pd.DataFrame({'a': [20, 10], 'b': [200, 100]}, index=[2, 1])
+        self.assert_frame_equal(result, expected)
+
+    def test_join_index(self):
+        # left / right
+
+        f = self.frame.loc[self.frame.index[:10], ['A', 'B']]
+        f2 = self.frame.loc[self.frame.index[5:], ['C', 'D']].iloc[::-1]
+
+        joined = f.join(f2)
+        self.assert_index_equal(f.index, joined.index)
+        expected_columns = pd.Index(['A', 'B', 'C', 'D'])
+        self.assert_index_equal(joined.columns, expected_columns)
+
+        joined = f.join(f2, how='left')
+        self.assert_index_equal(joined.index, f.index)
+        self.assert_index_equal(joined.columns, expected_columns)
+
+        joined = f.join(f2, how='right')
+        self.assert_index_equal(joined.index, f2.index)
+        self.assert_index_equal(joined.columns, expected_columns)
+
+        # inner
+
+        joined = f.join(f2, how='inner')
+        self.assert_index_equal(joined.index, f.index[5:10])
+        self.assert_index_equal(joined.columns, expected_columns)
+
+        # outer
+
+        joined = f.join(f2, how='outer')
+        self.assert_index_equal(joined.index, self.frame.index.sort_values())
+        self.assert_index_equal(joined.columns, expected_columns)
+
+        assertRaisesRegexp(ValueError, 'join method', f.join, f2, how='foo')
+
+        # corner case - overlapping columns
+        for how in ('outer', 'left', 'inner'):
+            with assertRaisesRegexp(ValueError, 'columns overlap but '
+                                    'no suffix'):
+                self.frame.join(self.frame, how=how)
+
+    def test_join_index_more(self):
+        af = self.frame.loc[:, ['A', 'B']]
+        bf = self.frame.loc[::2, ['C', 'D']]
+
+        expected = af.copy()
+        expected['C'] = self.frame['C'][::2]
+        expected['D'] = self.frame['D'][::2]
+
+        result = af.join(bf)
+        assert_frame_equal(result, expected)
+
+        result = af.join(bf, how='right')
+        assert_frame_equal(result, expected[::2])
+
+        result = bf.join(af, how='right')
+        assert_frame_equal(result, expected.loc[:, result.columns])
+
+    def test_join_index_series(self):
+        df = self.frame.copy()
+        s = df.pop(self.frame.columns[-1])
+        joined = df.join(s)
+
+        # TODO should this check_names ?
+        assert_frame_equal(joined, self.frame, check_names=False)
+
+        s.name = None
+        assertRaisesRegexp(ValueError, 'must have a name', df.join, s)
+
+    def test_join_overlap(self):
+        df1 = self.frame.loc[:, ['A', 'B', 'C']]
+        df2 = self.frame.loc[:, ['B', 'C', 'D']]
+
+        joined = df1.join(df2, lsuffix='_df1', rsuffix='_df2')
+        df1_suf = df1.loc[:, ['B', 'C']].add_suffix('_df1')
+        df2_suf = df2.loc[:, ['B', 'C']].add_suffix('_df2')
+
+        no_overlap = self.frame.loc[:, ['A', 'D']]
+        expected = df1_suf.join(df2_suf).join(no_overlap)
+
+        # column order not necessarily sorted
+        assert_frame_equal(joined, expected.loc[:, joined.columns])
+

pandas/tests/frame/test_misc_api.py

@@ -57,87 +57,6 @@ def test_get_value(self):
                 expected = self.frame[col][idx]
                 tm.assert_almost_equal(result, expected)
 
-    def test_join_index(self):
-        # left / right
-
-        f = self.frame.reindex(columns=['A', 'B'])[:10]
-        f2 = self.frame.reindex(columns=['C', 'D'])[5:][::-1]
-
-        joined = f.join(f2)
-        self.assert_index_equal(f.index, joined.index)
-        expected_columns = pd.Index(['A', 'B', 'C', 'D'])
-        self.assert_index_equal(joined.columns, expected_columns)
-
-        joined = f.join(f2, how='left')
-        self.assert_index_equal(joined.index, f.index)
-        self.assert_index_equal(joined.columns, expected_columns)
-
-        joined = f.join(f2, how='right')
-        self.assert_index_equal(joined.index, f2.index)
-        self.assert_index_equal(joined.columns, expected_columns)
-
-        # inner
-
-        joined = f.join(f2, how='inner')
-        self.assert_index_equal(joined.index, f.index.intersection(f2.index))
-        self.assert_index_equal(joined.columns, expected_columns)
-
-        # outer
-
-        joined = f.join(f2, how='outer')
-        self.assert_index_equal(joined.index, self.frame.index.sort_values())
-        self.assert_index_equal(joined.columns, expected_columns)
-
-        assertRaisesRegexp(ValueError, 'join method', f.join, f2, how='foo')
-
-        # corner case - overlapping columns
-        for how in ('outer', 'left', 'inner'):
-            with assertRaisesRegexp(ValueError, 'columns overlap but '
-                                    'no suffix'):
-                self.frame.join(self.frame, how=how)
-
-    def test_join_index_more(self):
-        af = self.frame.loc[:, ['A', 'B']]
-        bf = self.frame.loc[::2, ['C', 'D']]
-
-        expected = af.copy()
-        expected['C'] = self.frame['C'][::2]
-        expected['D'] = self.frame['D'][::2]
-
-        result = af.join(bf)
-        assert_frame_equal(result, expected)
-
-        result = af.join(bf, how='right')
-        assert_frame_equal(result, expected[::2])
-
-        result = bf.join(af, how='right')
-        assert_frame_equal(result, expected.loc[:, result.columns])
-
-    def test_join_index_series(self):
-        df = self.frame.copy()
-        s = df.pop(self.frame.columns[-1])
-        joined = df.join(s)
-
-        # TODO should this check_names ?
-        assert_frame_equal(joined, self.frame, check_names=False)
-
-        s.name = None
-        assertRaisesRegexp(ValueError, 'must have a name', df.join, s)
-
-    def test_join_overlap(self):
-        df1 = self.frame.loc[:, ['A', 'B', 'C']]
-        df2 = self.frame.loc[:, ['B', 'C', 'D']]
-
-        joined = df1.join(df2, lsuffix='_df1', rsuffix='_df2')
-        df1_suf = df1.loc[:, ['B', 'C']].add_suffix('_df1')
-        df2_suf = df2.loc[:, ['B', 'C']].add_suffix('_df2')
-
-        no_overlap = self.frame.loc[:, ['A', 'D']]
-        expected = df1_suf.join(df2_suf).join(no_overlap)
-
-        # column order not necessarily sorted
-        assert_frame_equal(joined, expected.loc[:, joined.columns])
-
     def test_add_prefix_suffix(self):
         with_prefix = self.frame.add_prefix('foo#')
         expected = pd.Index(['foo#%s' % c for c in self.frame.columns])

pandas/tests/indexes/test_base.py

@@ -629,13 +629,11 @@ def test_intersection(self):
         expected = Index([5, 3, 4], name='idx')
         result = idx1.intersection(idx2)
         self.assert_index_equal(result, expected)
-        self.assertEqual(result.name, expected.name)
 
         idx2 = Index([4, 7, 6, 5, 3], name='other')
         expected = Index([5, 3, 4], name=None)
         result = idx1.intersection(idx2)
         self.assert_index_equal(result, expected)
-        self.assertEqual(result.name, expected.name)
 
         # non-monotonic non-unique
         idx1 = Index(['A', 'B', 'A', 'C'])
@@ -644,6 +642,11 @@ def test_intersection(self):
         result = idx1.intersection(idx2)
         self.assert_index_equal(result, expected)
 
+        idx2 = Index(['B', 'D', 'A'])
+        expected = Index(['A', 'B', 'A'], dtype='object')
+        result = idx1.intersection(idx2)
+        self.assert_index_equal(result, expected)
+
         # preserve names
         first = self.strIndex[5:20]
         second = self.strIndex[:10]

pandas/tseries/index.py

@@ -1203,8 +1203,8 @@ def intersection(self, other):
               not other.offset.isAnchored() or
               (not self.is_monotonic or not other.is_monotonic)):
             result = Index.intersection(self, other)
-            result = self._simple_new(result._values, name=result.name,
-                                      tz=result.tz)
+            result = self._shallow_copy(result._values, name=result.name,
+                                        tz=result.tz, freq=None)
             if result.freq is None:
                 result.offset = to_offset(result.inferred_freq)
             return result