API: enable float slicing with .loc on int index

Author: jreback

pandas/core/index.py

@@ -2134,7 +2134,7 @@ def _maybe_cast_slice_bound(self, label, side):
         # pass thru float indexers if we have a numeric type index
         # which then can decide to process / or convert and warng
         if is_float(label):
-            if not self.is_floating():
+            if not (self.is_integer() or self.is_floating()):
                 self._invalid_indexer('slice',label)
 
         # we are not an integer based index, and we have an integer label

pandas/tests/test_index.py

@@ -969,11 +969,11 @@ def test_slice_locs(self):
 
         # int slicing with floats
         idx = Index(np.array([0, 1, 2, 5, 6, 7, 9, 10], dtype=int))
-        self.assertRaises(TypeError, lambda : idx.slice_locs(5.0, 10.0))
-        self.assertRaises(TypeError, lambda : idx.slice_locs(4.5, 10.5))
+        self.assertEqual(idx.slice_locs(5.0, 10.0), (3, n))
+        self.assertEqual(idx.slice_locs(4.5, 10.5), (3, 8))
         idx2 = idx[::-1]
-        self.assertRaises(TypeError, lambda : idx2.slice_locs(8.5, 1.5))
-        self.assertRaises(TypeError, lambda : idx2.slice_locs(10.5, -1))
+        self.assertEqual(idx2.slice_locs(8.5, 1.5), (2, 6))
+        self.assertEqual(idx2.slice_locs(10.5, -1), (0, n))
 
     def test_slice_locs_dup(self):
         idx = Index(['a', 'a', 'b', 'c', 'd', 'd'])

pandas/tests/test_indexing.py

@@ -709,10 +709,6 @@ def compare(result, expected):
             compare(df2, df1)
 
         # edge cases
-        s = Series(['a','b','c','d'], [1,2,3,4])
-        self.assertRaises(TypeError, lambda : s.ix[1.5:5.5])
-        self.assertRaises(TypeError, lambda : s.loc[1.5:5.5])
-
         s = Series([1,2,3,4], index=list('abde'))
 
         result1 = s['a':'c']
@@ -4047,7 +4043,7 @@ def check_slicing_positional(index):
 
         # int
         index = tm.makeIntIndex()
-        s = Series(np.arange(len(index))+10,index)
+        s = Series(np.arange(len(index))+10,index+5)
 
         # this is positional
         result1 = s[2:5]
@@ -4059,55 +4055,80 @@ def check_slicing_positional(index):
         result3 = s.loc[2:5]
         assert_series_equal(result2, result3)
 
-        # make all float slicing fail
-        self.assertRaises(TypeError, lambda : s.loc[2.0:5])
-        self.assertRaises(TypeError, lambda : s.loc[2.0:5.0])
-        self.assertRaises(TypeError, lambda : s.loc[2:5.0])
-        self.assertRaises(TypeError, lambda : s[2.0:5])
-        self.assertRaises(TypeError, lambda : s[2.0:5.0])
-        self.assertRaises(TypeError, lambda : s[2:5.0])
+        # float slicers on an int index
+        expected = Series([11,12,13],index=[6,7,8])
+        result = s.loc[6.0:8.5]
+        assert_series_equal(result, expected)
+
+        result = s.loc[5.5:8.5]
+        assert_series_equal(result, expected)
+
+        result = s.loc[5.5:8.0]
+        assert_series_equal(result, expected)
 
-        self.assertRaises(TypeError, lambda : s.ix[2.0:5])
-        self.assertRaises(TypeError, lambda : s.ix[2.0:5.0])
-        self.assertRaises(TypeError, lambda : s.ix[2:5.0])
+        # make all float slicing fail for ix/[] with an int index
+        self.assertRaises(TypeError, lambda : s[6.0:8])
+        self.assertRaises(TypeError, lambda : s[6.0:8.0])
+        self.assertRaises(TypeError, lambda : s[6:8.0])
+        self.assertRaises(TypeError, lambda : s.ix[6.0:8])
+        self.assertRaises(TypeError, lambda : s.ix[6.0:8.0])
+        self.assertRaises(TypeError, lambda : s.ix[6:8.0])
 
         # these work for now
-        #self.assertRaises(TypeError, lambda : s.iloc[2.0:5])
-        #self.assertRaises(TypeError, lambda : s.iloc[2.0:5.0])
-        #self.assertRaises(TypeError, lambda : s.iloc[2:5.0])
+        #self.assertRaises(TypeError, lambda : s.iloc[6.0:8])
+        #self.assertRaises(TypeError, lambda : s.iloc[6.0:8.0])
+        #self.assertRaises(TypeError, lambda : s.iloc[6:8.0])
 
         # float
         index = tm.makeFloatIndex()
-        s = Series(np.arange(len(index))+10,index=index)
+        s = Series(np.arange(len(index))+10,index=index+5)
 
         # these are all value based
-        result1 = s[2:5]
-        result2 = s.ix[2:5]
-        result3 = s.loc[2:5]
+        result1 = s[6:8]
+        result2 = s.ix[6:8]
+        result3 = s.loc[6:8]
         assert_series_equal(result1, result2)
         assert_series_equal(result1, result3)
 
         # these are all valid
-        result1a = s[2.0:5]
-        result2a = s[2.0:5.0]
-        result3a = s[2:5.0]
+        result1a = s[6.0:8]
+        result2a = s[6.0:8.0]
+        result3a = s[6:8.0]
+        result1b = s[6.5:8]
+        result2b = s[6.5:8.5]
+        result3b = s[6:8.5]
         assert_series_equal(result1a, result2a)
         assert_series_equal(result1a, result3a)
-
-        result1b = s.ix[2.0:5]
-        result2b = s.ix[2.0:5.0]
-        result3b = s.ix[2:5.0]
-        assert_series_equal(result1b, result2b)
-        assert_series_equal(result1b, result3b)
-
-        result1c = s.loc[2.0:5]
-        result2c = s.loc[2.0:5.0]
-        result3c = s.loc[2:5.0]
-        assert_series_equal(result1c, result2c)
-        assert_series_equal(result1c, result3c)
-
         assert_series_equal(result1a, result1b)
+        assert_series_equal(result1a, result2b)
+        assert_series_equal(result1a, result3b)
+
+        result1c = s.ix[6.0:8]
+        result2c = s.ix[6.0:8.0]
+        result3c = s.ix[6:8.0]
+        result1d = s.ix[6.5:8]
+        result2d = s.ix[6.5:8.5]
+        result3d = s.ix[6:8.5]
         assert_series_equal(result1a, result1c)
+        assert_series_equal(result1a, result2c)
+        assert_series_equal(result1a, result3c)
+        assert_series_equal(result1a, result1d)
+        assert_series_equal(result1a, result2d)
+        assert_series_equal(result1a, result3d)
+
+        result1e = s.loc[6.0:8]
+        result2e = s.loc[6.0:8.0]
+        result3e = s.loc[6:8.0]
+        result1f = s.loc[6.5:8]
+        result2f = s.loc[6.5:8.5]
+        result3f = s.loc[6:8.5]
+        assert_series_equal(result1a, result1e)
+        assert_series_equal(result1a, result2e)
+        assert_series_equal(result1a, result3e)
+        assert_series_equal(result1a, result1f)
+        assert_series_equal(result1a, result2f)
+        assert_series_equal(result1a, result3f)
+
 
         # these work for now
         #self.assertRaises(TypeError, lambda : s.iloc[2.0:5])