Merge remote-tracking branch 'refs/remotes/pydata/master' into Fix-for-pandas-dev#11317

Author: Dr-Irv

doc/source/whatsnew/v0.17.1.txt

@@ -17,6 +17,7 @@ Highlights include:
 
 Enhancements
 ~~~~~~~~~~~~
+- ``DatetimeIndex`` now supports conversion to strings with astype(str)(:issue:`10442`)
 
 - Support for ``compression`` (gzip/bz2) in :method:`DataFrame.to_csv` (:issue:`7615`)
 
@@ -64,8 +65,8 @@ Bug Fixes
 
 - Bug in ``HDFStore.select`` when comparing with a numpy scalar in a where clause (:issue:`11283`)
 
-- Bug in tz-conversions with an ambiguous time and ``.dt`` accessors (:issues:`11295`)
-
+- Bug in tz-conversions with an ambiguous time and ``.dt`` accessors (:issue:`11295`)
+- Bug in comparisons of Series vs list-likes (:issue:`11339`)
 
 - Bug in list-like indexing with a mixed-integer Index (:issue:`11320`)
 

pandas/core/ops.py

@@ -720,7 +720,7 @@ def wrapper(self, other, axis=None):
             res = op(self.values, other)
         else:
             values = self.get_values()
-            if is_list_like(other):
+            if isinstance(other, (list, np.ndarray)):
                 other = np.asarray(other)
 
             res = na_op(values, other)

pandas/tests/test_series.py

@@ -4269,6 +4269,43 @@ def test_object_comparisons(self):
         expected = -(s == 'a')
         assert_series_equal(result, expected)
 
+    def test_comparison_tuples(self):
+        # GH11339
+        # comparisons vs tuple
+        s = Series([(1,1),(1,2)])
+
+        result = s == (1,2)
+        expected = Series([False,True])
+        assert_series_equal(result, expected)
+
+        result = s != (1,2)
+        expected = Series([True, False])
+        assert_series_equal(result, expected)
+
+        result = s == (0,0)
+        expected = Series([False, False])
+        assert_series_equal(result, expected)
+
+        result = s != (0,0)
+        expected = Series([True, True])
+        assert_series_equal(result, expected)
+
+        s = Series([(1,1),(1,1)])
+
+        result = s == (1,1)
+        expected = Series([True, True])
+        assert_series_equal(result, expected)
+
+        result = s != (1,1)
+        expected = Series([False, False])
+        assert_series_equal(result, expected)
+
+        s = Series([frozenset([1]),frozenset([1,2])])
+
+        result = s == frozenset([1])
+        expected = Series([True, False])
+        assert_series_equal(result, expected)
+
     def test_comparison_operators_with_nas(self):
         s = Series(bdate_range('1/1/2000', periods=10), dtype=object)
         s[::2] = np.nan

pandas/tseries/index.py

@@ -756,6 +756,8 @@ def astype(self, dtype):
             return self.asi8.copy()
         elif dtype == _NS_DTYPE and self.tz is not None:
             return self.tz_convert('UTC').tz_localize(None)
+        elif dtype == str:
+            return self._shallow_copy(values=self.format(), infer=True)
         else:  # pragma: no cover
             raise ValueError('Cannot cast DatetimeIndex to dtype %s' % dtype)
 

pandas/tseries/tests/test_base.py

@@ -45,6 +45,32 @@ def test_ops_properties_basic(self):
         self.assertEqual(s.day,10)
         self.assertRaises(AttributeError, lambda : s.weekday)
 
+    def test_astype_str(self):
+        # test astype string - #10442
+        result = date_range('2012-01-01', periods=4, name='test_name').astype(str)
+        expected = Index(['2012-01-01', '2012-01-02', '2012-01-03','2012-01-04'],
+                            name='test_name', dtype=object)
+        tm.assert_index_equal(result, expected)
+
+        # test astype string with tz and name
+        result = date_range('2012-01-01', periods=3, name='test_name', tz='US/Eastern').astype(str)
+        expected = Index(['2012-01-01 00:00:00-05:00', '2012-01-02 00:00:00-05:00',
+                          '2012-01-03 00:00:00-05:00'], name='test_name', dtype=object)
+        tm.assert_index_equal(result, expected)
+
+        # test astype string with freqH and name
+        result = date_range('1/1/2011', periods=3, freq='H', name='test_name').astype(str)
+        expected = Index(['2011-01-01 00:00:00', '2011-01-01 01:00:00', '2011-01-01 02:00:00'],
+                         name='test_name', dtype=object)
+        tm.assert_index_equal(result, expected)
+
+        # test astype string with freqH and timezone
+        result = date_range('3/6/2012 00:00', periods=2, freq='H',
+                            tz='Europe/London', name='test_name').astype(str)
+        expected = Index(['2012-03-06 00:00:00+00:00', '2012-03-06 01:00:00+00:00'],
+                         dtype=object, name='test_name')
+        tm.assert_index_equal(result, expected)
+
     def test_asobject_tolist(self):
         idx = pd.date_range(start='2013-01-01', periods=4, freq='M', name='idx')
         expected_list = [pd.Timestamp('2013-01-31'), pd.Timestamp('2013-02-28'),
@@ -503,7 +529,6 @@ def test_infer_freq(self):
             tm.assert_index_equal(idx, result)
             self.assertEqual(result.freq, freq)
 
-
 class TestTimedeltaIndexOps(Ops):
 
     def setUp(self):

pandas/tseries/tests/test_timeseries.py

@@ -2223,6 +2223,7 @@ def test_append_join_nondatetimeindex(self):
         # it works
         rng.join(idx, how='outer')
 
+
     def test_astype(self):
         rng = date_range('1/1/2000', periods=10)
 
@@ -2235,6 +2236,17 @@ def test_astype(self):
         expected = date_range('1/1/2000', periods=10, tz='US/Eastern').tz_convert('UTC').tz_localize(None)
         tm.assert_index_equal(result, expected)
 
+        # BUG#10442 : testing astype(str) is correct for Series/DatetimeIndex
+        result = pd.Series(pd.date_range('2012-01-01', periods=3)).astype(str)
+        expected = pd.Series(['2012-01-01', '2012-01-02', '2012-01-03'], dtype=object)
+        tm.assert_series_equal(result, expected)
+
+        result = Series(pd.date_range('2012-01-01', periods=3, tz='US/Eastern')).astype(str)
+        expected = Series(['2012-01-01 00:00:00-05:00', '2012-01-02 00:00:00-05:00', '2012-01-03 00:00:00-05:00'],
+                          dtype=object)
+        tm.assert_series_equal(result, expected)
+
+
     def test_to_period_nofreq(self):
         idx = DatetimeIndex(['2000-01-01', '2000-01-02', '2000-01-04'])
         self.assertRaises(ValueError, idx.to_period)