diff --git a/pandas/tests/dtypes/test_inference.py b/pandas/tests/dtypes/test_inference.py
index 47441dc49840d..77a80531159e4 100644
--- a/pandas/tests/dtypes/test_inference.py
+++ b/pandas/tests/dtypes/test_inference.py
@@ -16,7 +16,6 @@
 import pytz
 
 from pandas._libs import iNaT, lib, missing as libmissing
-from pandas.compat import lrange
 import pandas.util._test_decorators as td
 
 from pandas.core.dtypes import inference
@@ -1302,8 +1301,7 @@ def test_datetimeindex_from_empty_datetime64_array():
 def test_nan_to_nat_conversions():
 
     df = DataFrame(dict({
-        'A': np.asarray(
-            lrange(10), dtype='float64'),
+        'A': np.asarray(range(10), dtype='float64'),
         'B': Timestamp('20010101')
     }))
     df.iloc[3:6, :] = np.nan
diff --git a/pandas/tests/frame/test_alter_axes.py b/pandas/tests/frame/test_alter_axes.py
index 5e8c9f030d34c..0e3346149149e 100644
--- a/pandas/tests/frame/test_alter_axes.py
+++ b/pandas/tests/frame/test_alter_axes.py
@@ -4,8 +4,6 @@
 import numpy as np
 import pytest
 
-from pandas.compat import lrange
-
 from pandas.core.dtypes.common import (
     is_categorical_dtype, is_interval_dtype, is_object_dtype)
 
@@ -1091,13 +1089,13 @@ def test_reset_index_multiindex_col(self):
         tm.assert_frame_equal(rs, xp)
 
         rs = df.reset_index('a', col_fill=None)
-        xp = DataFrame(full, Index(lrange(3), name='d'),
+        xp = DataFrame(full, Index(range(3), name='d'),
                        columns=[['a', 'b', 'b', 'c'],
                                 ['a', 'mean', 'median', 'mean']])
         tm.assert_frame_equal(rs, xp)
 
         rs = df.reset_index('a', col_fill='blah', col_level=1)
-        xp = DataFrame(full, Index(lrange(3), name='d'),
+        xp = DataFrame(full, Index(range(3), name='d'),
                        columns=[['blah', 'b', 'b', 'c'],
                                 ['a', 'mean', 'median', 'mean']])
         tm.assert_frame_equal(rs, xp)
diff --git a/pandas/tests/frame/test_analytics.py b/pandas/tests/frame/test_analytics.py
index 552bd61e8c8d9..effe7eb47323d 100644
--- a/pandas/tests/frame/test_analytics.py
+++ b/pandas/tests/frame/test_analytics.py
@@ -6,7 +6,6 @@
 import numpy as np
 import pytest
 
-from pandas.compat import lrange
 import pandas.util._test_decorators as td
 
 import pandas as pd
@@ -54,7 +53,7 @@ def assert_stat_op_calc(opname, alternative, frame, has_skipna=True,
         result = getattr(df, opname)()
         assert isinstance(result, Series)
 
-        df['a'] = lrange(len(df))
+        df['a'] = range(len(df))
         result = getattr(df, opname)()
         assert isinstance(result, Series)
         assert len(result)
@@ -1203,7 +1202,7 @@ def test_stats_mixed_type(self, float_string_frame):
         float_string_frame.skew(1)
 
     def test_sum_bools(self):
-        df = DataFrame(index=lrange(1), columns=lrange(10))
+        df = DataFrame(index=range(1), columns=range(10))
         bools = isna(df)
         assert bools.sum(axis=1)[0] == 10
 
@@ -1212,7 +1211,7 @@ def test_sum_bools(self):
 
     def test_cumsum_corner(self):
         dm = DataFrame(np.arange(20).reshape(4, 5),
-                       index=lrange(4), columns=lrange(5))
+                       index=range(4), columns=range(5))
         # ?(wesm)
         result = dm.cumsum()  # noqa
 
@@ -1327,12 +1326,12 @@ def test_count(self):
         assert isinstance(ct2, Series)
 
         # GH#423
-        df = DataFrame(index=lrange(10))
+        df = DataFrame(index=range(10))
         result = df.count(1)
         expected = Series(0, index=df.index)
         tm.assert_series_equal(result, expected)
 
-        df = DataFrame(columns=lrange(10))
+        df = DataFrame(columns=range(10))
         result = df.count(0)
         expected = Series(0, index=df.columns)
         tm.assert_series_equal(result, expected)
@@ -2137,9 +2136,9 @@ def test_dot(self):
 
         # unaligned
         df = DataFrame(np.random.randn(3, 4),
-                       index=[1, 2, 3], columns=lrange(4))
+                       index=[1, 2, 3], columns=range(4))
         df2 = DataFrame(np.random.randn(5, 3),
-                        index=lrange(5), columns=[1, 2, 3])
+                        index=range(5), columns=[1, 2, 3])
 
         with pytest.raises(ValueError, match='aligned'):
             df.dot(df2)
@@ -2197,9 +2196,9 @@ def test_matmul(self):
 
         # unaligned
         df = DataFrame(np.random.randn(3, 4),
-                       index=[1, 2, 3], columns=lrange(4))
+                       index=[1, 2, 3], columns=range(4))
         df2 = DataFrame(np.random.randn(5, 3),
-                        index=lrange(5), columns=[1, 2, 3])
+                        index=range(5), columns=[1, 2, 3])
 
         with pytest.raises(ValueError, match='aligned'):
             operator.matmul(df, df2)
diff --git a/pandas/tests/frame/test_api.py b/pandas/tests/frame/test_api.py
index b6419492b5b4b..8013ddfeb38f9 100644
--- a/pandas/tests/frame/test_api.py
+++ b/pandas/tests/frame/test_api.py
@@ -4,8 +4,6 @@
 import numpy as np
 import pytest
 
-from pandas.compat import lrange
-
 import pandas as pd
 from pandas import (
     Categorical, DataFrame, Series, SparseDataFrame, compat, date_range,
@@ -234,7 +232,7 @@ def test_itertuples(self, float_frame):
             self._assert_series_equal(s, expected)
 
         df = self.klass({'floats': np.random.randn(5),
-                         'ints': lrange(5)}, columns=['floats', 'ints'])
+                         'ints': range(5)}, columns=['floats', 'ints'])
 
         for tup in df.itertuples(index=False):
             assert isinstance(tup[1], int)
diff --git a/pandas/tests/frame/test_axis_select_reindex.py b/pandas/tests/frame/test_axis_select_reindex.py
index d1934c335a395..ad6c66c911615 100644
--- a/pandas/tests/frame/test_axis_select_reindex.py
+++ b/pandas/tests/frame/test_axis_select_reindex.py
@@ -3,7 +3,6 @@
 import numpy as np
 import pytest
 
-from pandas.compat import lrange
 from pandas.errors import PerformanceWarning
 
 import pandas as pd
@@ -393,44 +392,44 @@ def test_reindex_fill_value(self):
         df = DataFrame(np.random.randn(10, 4))
 
         # axis=0
-        result = df.reindex(lrange(15))
+        result = df.reindex(list(range(15)))
         assert np.isnan(result.values[-5:]).all()
 
-        result = df.reindex(lrange(15), fill_value=0)
-        expected = df.reindex(lrange(15)).fillna(0)
+        result = df.reindex(range(15), fill_value=0)
+        expected = df.reindex(range(15)).fillna(0)
         assert_frame_equal(result, expected)
 
         # axis=1
-        result = df.reindex(columns=lrange(5), fill_value=0.)
+        result = df.reindex(columns=range(5), fill_value=0.)
         expected = df.copy()
         expected[4] = 0.
         assert_frame_equal(result, expected)
 
-        result = df.reindex(columns=lrange(5), fill_value=0)
+        result = df.reindex(columns=range(5), fill_value=0)
         expected = df.copy()
         expected[4] = 0
         assert_frame_equal(result, expected)
 
-        result = df.reindex(columns=lrange(5), fill_value='foo')
+        result = df.reindex(columns=range(5), fill_value='foo')
         expected = df.copy()
         expected[4] = 'foo'
         assert_frame_equal(result, expected)
 
         # reindex_axis
         with tm.assert_produces_warning(FutureWarning):
-            result = df.reindex_axis(lrange(15), fill_value=0., axis=0)
-        expected = df.reindex(lrange(15)).fillna(0)
+            result = df.reindex_axis(range(15), fill_value=0., axis=0)
+        expected = df.reindex(range(15)).fillna(0)
         assert_frame_equal(result, expected)
 
         with tm.assert_produces_warning(FutureWarning):
-            result = df.reindex_axis(lrange(5), fill_value=0., axis=1)
-        expected = df.reindex(columns=lrange(5)).fillna(0)
+            result = df.reindex_axis(range(5), fill_value=0., axis=1)
+        expected = df.reindex(columns=range(5)).fillna(0)
         assert_frame_equal(result, expected)
 
         # other dtypes
         df['foo'] = 'foo'
-        result = df.reindex(lrange(15), fill_value=0)
-        expected = df.reindex(lrange(15)).fillna(0)
+        result = df.reindex(range(15), fill_value=0)
+        expected = df.reindex(range(15)).fillna(0)
         assert_frame_equal(result, expected)
 
     def test_reindex_dups(self):
@@ -1025,7 +1024,7 @@ def test_reindex_boolean(self):
         assert reindexed.values.dtype == np.object_
         assert isna(reindexed[0][1])
 
-        reindexed = frame.reindex(columns=lrange(3))
+        reindexed = frame.reindex(columns=range(3))
         assert reindexed.values.dtype == np.object_
         assert isna(reindexed[1]).all()
 
@@ -1093,22 +1092,22 @@ def test_reindex_with_nans(self):
     def test_reindex_multi(self):
         df = DataFrame(np.random.randn(3, 3))
 
-        result = df.reindex(index=lrange(4), columns=lrange(4))
-        expected = df.reindex(lrange(4)).reindex(columns=lrange(4))
+        result = df.reindex(index=range(4), columns=range(4))
+        expected = df.reindex(list(range(4))).reindex(columns=range(4))
 
         assert_frame_equal(result, expected)
 
         df = DataFrame(np.random.randint(0, 10, (3, 3)))
 
-        result = df.reindex(index=lrange(4), columns=lrange(4))
-        expected = df.reindex(lrange(4)).reindex(columns=lrange(4))
+        result = df.reindex(index=range(4), columns=range(4))
+        expected = df.reindex(list(range(4))).reindex(columns=range(4))
 
         assert_frame_equal(result, expected)
 
         df = DataFrame(np.random.randint(0, 10, (3, 3)))
 
-        result = df.reindex(index=lrange(2), columns=lrange(2))
-        expected = df.reindex(lrange(2)).reindex(columns=lrange(2))
+        result = df.reindex(index=range(2), columns=range(2))
+        expected = df.reindex(range(2)).reindex(columns=range(2))
 
         assert_frame_equal(result, expected)
 
diff --git a/pandas/tests/frame/test_combine_concat.py b/pandas/tests/frame/test_combine_concat.py
index 1fbfefba9ff13..c05a86754afbc 100644
--- a/pandas/tests/frame/test_combine_concat.py
+++ b/pandas/tests/frame/test_combine_concat.py
@@ -3,8 +3,6 @@
 import numpy as np
 import pytest
 
-from pandas.compat import lrange
-
 import pandas as pd
 from pandas import DataFrame, Index, Series, Timestamp, date_range
 import pandas.util.testing as tm
@@ -216,41 +214,41 @@ def test_append_dtypes(self):
         # row appends of different dtypes (so need to do by-item)
         # can sometimes infer the correct type
 
-        df1 = DataFrame({'bar': Timestamp('20130101')}, index=lrange(5))
+        df1 = DataFrame({'bar': Timestamp('20130101')}, index=range(5))
         df2 = DataFrame()
         result = df1.append(df2)
         expected = df1.copy()
         assert_frame_equal(result, expected)
 
-        df1 = DataFrame({'bar': Timestamp('20130101')}, index=lrange(1))
-        df2 = DataFrame({'bar': 'foo'}, index=lrange(1, 2))
+        df1 = DataFrame({'bar': Timestamp('20130101')}, index=range(1))
+        df2 = DataFrame({'bar': 'foo'}, index=range(1, 2))
         result = df1.append(df2)
         expected = DataFrame({'bar': [Timestamp('20130101'), 'foo']})
         assert_frame_equal(result, expected)
 
-        df1 = DataFrame({'bar': Timestamp('20130101')}, index=lrange(1))
-        df2 = DataFrame({'bar': np.nan}, index=lrange(1, 2))
+        df1 = DataFrame({'bar': Timestamp('20130101')}, index=range(1))
+        df2 = DataFrame({'bar': np.nan}, index=range(1, 2))
         result = df1.append(df2)
         expected = DataFrame(
             {'bar': Series([Timestamp('20130101'), np.nan], dtype='M8[ns]')})
         assert_frame_equal(result, expected)
 
-        df1 = DataFrame({'bar': Timestamp('20130101')}, index=lrange(1))
-        df2 = DataFrame({'bar': np.nan}, index=lrange(1, 2), dtype=object)
+        df1 = DataFrame({'bar': Timestamp('20130101')}, index=range(1))
+        df2 = DataFrame({'bar': np.nan}, index=range(1, 2), dtype=object)
         result = df1.append(df2)
         expected = DataFrame(
             {'bar': Series([Timestamp('20130101'), np.nan], dtype='M8[ns]')})
         assert_frame_equal(result, expected)
 
-        df1 = DataFrame({'bar': np.nan}, index=lrange(1))
-        df2 = DataFrame({'bar': Timestamp('20130101')}, index=lrange(1, 2))
+        df1 = DataFrame({'bar': np.nan}, index=range(1))
+        df2 = DataFrame({'bar': Timestamp('20130101')}, index=range(1, 2))
         result = df1.append(df2)
         expected = DataFrame(
             {'bar': Series([np.nan, Timestamp('20130101')], dtype='M8[ns]')})
         assert_frame_equal(result, expected)
 
-        df1 = DataFrame({'bar': Timestamp('20130101')}, index=lrange(1))
-        df2 = DataFrame({'bar': 1}, index=lrange(1, 2), dtype=object)
+        df1 = DataFrame({'bar': Timestamp('20130101')}, index=range(1))
+        df2 = DataFrame({'bar': 1}, index=range(1, 2), dtype=object)
         result = df1.append(df2)
         expected = DataFrame({'bar': Series([Timestamp('20130101'), 1])})
         assert_frame_equal(result, expected)
@@ -379,7 +377,7 @@ def test_join_str_datetime(self):
         str_dates = ['20120209', '20120222']
         dt_dates = [datetime(2012, 2, 9), datetime(2012, 2, 22)]
 
-        A = DataFrame(str_dates, index=lrange(2), columns=['aa'])
+        A = DataFrame(str_dates, index=range(2), columns=['aa'])
         C = DataFrame([[1, 2], [3, 4]], index=str_dates, columns=dt_dates)
 
         tst = A.join(C, on='aa')
@@ -535,12 +533,12 @@ def test_concat_astype_dup_col(self):
 class TestDataFrameCombineFirst():
 
     def test_combine_first_mixed(self):
-        a = Series(['a', 'b'], index=lrange(2))
-        b = Series(lrange(2), index=lrange(2))
+        a = Series(['a', 'b'], index=range(2))
+        b = Series(range(2), index=range(2))
         f = DataFrame({'A': a, 'B': b})
 
-        a = Series(['a', 'b'], index=lrange(5, 7))
-        b = Series(lrange(2), index=lrange(5, 7))
+        a = Series(['a', 'b'], index=range(5, 7))
+        b = Series(range(2), index=range(5, 7))
         g = DataFrame({'A': a, 'B': b})
 
         exp = pd.DataFrame({'A': list('abab'), 'B': [0., 1., 0., 1.]},
@@ -861,7 +859,7 @@ def test_concat_datetime_datetime64_frame(self):
         df2_obj = DataFrame.from_records(rows, columns=['date', 'test'])
 
         ind = date_range(start="2000/1/1", freq="D", periods=10)
-        df1 = DataFrame({'date': ind, 'test': lrange(10)})
+        df1 = DataFrame({'date': ind, 'test': range(10)})
 
         # it works!
         pd.concat([df1, df2_obj])
diff --git a/pandas/tests/frame/test_constructors.py b/pandas/tests/frame/test_constructors.py
index 5786f1dcce289..0ec533f4d8b50 100644
--- a/pandas/tests/frame/test_constructors.py
+++ b/pandas/tests/frame/test_constructors.py
@@ -7,7 +7,7 @@
 import numpy.ma as ma
 import pytest
 
-from pandas.compat import PY36, is_platform_little_endian, lmap, lrange
+from pandas.compat import PY36, is_platform_little_endian, lmap
 
 from pandas.core.dtypes.cast import construct_1d_object_array_from_listlike
 from pandas.core.dtypes.common import is_integer_dtype
@@ -116,7 +116,7 @@ def test_constructor_list_frames(self):
         result = DataFrame([DataFrame()])
         assert result.shape == (1, 0)
 
-        result = DataFrame([DataFrame(dict(A=lrange(5)))])
+        result = DataFrame([DataFrame(dict(A=np.arange(5)))])
         assert isinstance(result.iloc[0, 0], DataFrame)
 
     def test_constructor_mixed_dtypes(self):
@@ -234,7 +234,7 @@ def test_constructor_int_overflow(self, values):
     def test_constructor_ordereddict(self):
         import random
         nitems = 100
-        nums = lrange(nitems)
+        nums = list(range(nitems))
         random.shuffle(nums)
         expected = ['A%d' % i for i in nums]
         df = DataFrame(OrderedDict(zip(expected, [[0]] * nitems)))
@@ -676,14 +676,14 @@ def _check_basic_constructor(self, empty):
 
         # automatic labeling
         frame = DataFrame(mat)
-        tm.assert_index_equal(frame.index, pd.Index(lrange(2)))
-        tm.assert_index_equal(frame.columns, pd.Index(lrange(3)))
+        tm.assert_index_equal(frame.index, pd.Int64Index(range(2)))
+        tm.assert_index_equal(frame.columns, pd.Int64Index(range(3)))
 
         frame = DataFrame(mat, index=[1, 2])
-        tm.assert_index_equal(frame.columns, pd.Index(lrange(3)))
+        tm.assert_index_equal(frame.columns, pd.Int64Index(range(3)))
 
         frame = DataFrame(mat, columns=['A', 'B', 'C'])
-        tm.assert_index_equal(frame.index, pd.Index(lrange(2)))
+        tm.assert_index_equal(frame.index, pd.Int64Index(range(2)))
 
         # 0-length axis
         frame = DataFrame(empty((0, 3)))
@@ -862,11 +862,11 @@ def test_constructor_corner_shape(self):
         assert df.values.shape == (0, 0)
 
     @pytest.mark.parametrize("data, index, columns, dtype, expected", [
-        (None, lrange(10), ['a', 'b'], object, np.object_),
+        (None, list(range(10)), ['a', 'b'], object, np.object_),
         (None, None, ['a', 'b'], 'int64', np.dtype('int64')),
-        (None, lrange(10), ['a', 'b'], int, np.dtype('float64')),
+        (None, list(range(10)), ['a', 'b'], int, np.dtype('float64')),
         ({}, None, ['foo', 'bar'], None, np.object_),
-        ({'b': 1}, lrange(10), list('abc'), int, np.dtype('float64'))
+        ({'b': 1}, list(range(10)), list('abc'), int, np.dtype('float64'))
     ])
     def test_constructor_dtype(self, data, index, columns, dtype, expected):
         df = DataFrame(data, index, columns, dtype)
@@ -1171,7 +1171,7 @@ def test_constructor_ragged(self):
             DataFrame(data)
 
     def test_constructor_scalar(self):
-        idx = Index(lrange(3))
+        idx = Index(range(3))
         df = DataFrame({"a": 0}, index=idx)
         expected = DataFrame({"a": [0, 0, 0]}, index=idx)
         tm.assert_frame_equal(df, expected, check_dtype=False)
@@ -1683,12 +1683,12 @@ def test_constructor_for_list_with_dtypes(self):
         expected = Series({'float64': 1})
         tm.assert_series_equal(result, expected)
 
-        df = DataFrame({'a': 1}, index=lrange(3))
+        df = DataFrame({'a': 1}, index=range(3))
         result = df.get_dtype_counts()
         expected = Series({'int64': 1})
         tm.assert_series_equal(result, expected)
 
-        df = DataFrame({'a': 1.}, index=lrange(3))
+        df = DataFrame({'a': 1.}, index=range(3))
         result = df.get_dtype_counts()
         expected = Series({'float64': 1})
         tm.assert_series_equal(result, expected)
@@ -2131,7 +2131,7 @@ def test_from_records_sequencelike(self):
 
         # tuples is in the order of the columns
         result = DataFrame.from_records(tuples)
-        tm.assert_index_equal(result.columns, pd.Index(lrange(8)))
+        tm.assert_index_equal(result.columns, pd.RangeIndex(8))
 
         # test exclude parameter & we are casting the results here (as we don't
         # have dtype info to recover)
diff --git a/pandas/tests/frame/test_indexing.py b/pandas/tests/frame/test_indexing.py
index 3888739a0b279..104886bb3e446 100644
--- a/pandas/tests/frame/test_indexing.py
+++ b/pandas/tests/frame/test_indexing.py
@@ -5,7 +5,6 @@
 import pytest
 
 from pandas._libs.tslib import iNaT
-from pandas.compat import lrange
 
 from pandas.core.dtypes.common import is_float_dtype, is_integer, is_scalar
 from pandas.core.dtypes.dtypes import CategoricalDtype
@@ -159,7 +158,8 @@ def test_setitem_list(self):
         with pytest.raises(ValueError, match=msg):
             data['A'] = range(len(data.index) - 1)
 
-        df = DataFrame(0, lrange(3), ['tt1', 'tt2'], dtype=np.int_)
+        df = DataFrame(0, index=range(3), columns=['tt1', 'tt2'],
+                       dtype=np.int_)
         df.loc[1, ['tt1', 'tt2']] = [1, 2]
 
         result = df.loc[df.index[1], ['tt1', 'tt2']]
@@ -432,7 +432,7 @@ def test_getattr(self):
             self.frame.NONEXISTENT_NAME
 
     def test_setattr_column(self):
-        df = DataFrame({'foobar': 1}, index=lrange(10))
+        df = DataFrame({'foobar': 1}, index=range(10))
 
         df.foobar = 5
         assert (df.foobar == 5).all()
@@ -636,8 +636,7 @@ def test_setitem_boolean_column(self):
     def test_frame_setitem_timestamp(self):
         # GH#2155
         columns = date_range(start='1/1/2012', end='2/1/2012', freq=BDay())
-        index = lrange(10)
-        data = DataFrame(columns=columns, index=index)
+        data = DataFrame(columns=columns, index=range(10))
         t = datetime(2012, 11, 1)
         ts = Timestamp(t)
         data[ts] = np.nan  # works, mostly a smoke-test
@@ -705,11 +704,11 @@ def test_setitem_ambig(self):
         from decimal import Decimal
 
         # Created as float type
-        dm = DataFrame(index=lrange(3), columns=lrange(3))
+        dm = DataFrame(index=range(3), columns=range(3))
 
         coercable_series = Series([Decimal(1) for _ in range(3)],
-                                  index=lrange(3))
-        uncoercable_series = Series(['foo', 'bzr', 'baz'], index=lrange(3))
+                                  index=range(3))
+        uncoercable_series = Series(['foo', 'bzr', 'baz'], index=range(3))
 
         dm[0] = np.ones(3)
         assert len(dm.columns) == 3
@@ -866,7 +865,7 @@ def test_getitem_fancy_slice_integers_step(self):
         assert isna(df.iloc[:8:2]).values.all()
 
     def test_getitem_setitem_integer_slice_keyerrors(self):
-        df = DataFrame(np.random.randn(10, 5), index=lrange(0, 20, 2))
+        df = DataFrame(np.random.randn(10, 5), index=range(0, 20, 2))
 
         # this is OK
         cp = df.copy()
@@ -886,7 +885,7 @@ def test_getitem_setitem_integer_slice_keyerrors(self):
         assert_frame_equal(result2, expected)
 
         # non-monotonic, raise KeyError
-        df2 = df.iloc[lrange(5) + lrange(5, 10)[::-1]]
+        df2 = df.iloc[list(range(5)) + list(range(5, 10))[::-1]]
         with pytest.raises(KeyError, match=r"^3$"):
             df2.loc[3:11]
         with pytest.raises(KeyError, match=r"^3$"):
@@ -1870,7 +1869,7 @@ def test_set_value_resize(self):
 
     def test_set_value_with_index_dtype_change(self):
         df_orig = DataFrame(np.random.randn(3, 3),
-                            index=lrange(3), columns=list('ABC'))
+                            index=range(3), columns=list('ABC'))
 
         # this is actually ambiguous as the 2 is interpreted as a positional
         # so column is not created
@@ -1902,7 +1901,7 @@ def test_set_value_with_index_dtype_change(self):
     def test_get_set_value_no_partial_indexing(self):
         # partial w/ MultiIndex raise exception
         index = MultiIndex.from_tuples([(0, 1), (0, 2), (1, 1), (1, 2)])
-        df = DataFrame(index=index, columns=lrange(4))
+        df = DataFrame(index=index, columns=range(4))
         with tm.assert_produces_warning(FutureWarning,
                                         check_stacklevel=False):
             with pytest.raises(KeyError, match=r"^0$"):
@@ -1940,7 +1939,7 @@ def test_single_element_ix_dont_upcast(self):
         assert_series_equal(result, expected)
 
     def test_iloc_row(self):
-        df = DataFrame(np.random.randn(10, 4), index=lrange(0, 20, 2))
+        df = DataFrame(np.random.randn(10, 4), index=range(0, 20, 2))
 
         result = df.iloc[1]
         exp = df.loc[2]
@@ -1971,7 +1970,7 @@ def test_iloc_row(self):
 
     def test_iloc_col(self):
 
-        df = DataFrame(np.random.randn(4, 10), columns=lrange(0, 20, 2))
+        df = DataFrame(np.random.randn(4, 10), columns=range(0, 20, 2))
 
         result = df.iloc[:, 1]
         exp = df.loc[:, 2]
@@ -2158,7 +2157,7 @@ def test_reindex_frame_add_nat(self):
         rng = date_range('1/1/2000 00:00:00', periods=10, freq='10s')
         df = DataFrame({'A': np.random.randn(len(rng)), 'B': rng})
 
-        result = df.reindex(lrange(15))
+        result = df.reindex(range(15))
         assert np.issubdtype(result['B'].dtype, np.dtype('M8[ns]'))
 
         mask = com.isna(result)['B']
@@ -2511,7 +2510,7 @@ def test_xs_view(self):
         # this is numpy dependent
 
         dm = DataFrame(np.arange(20.).reshape(4, 5),
-                       index=lrange(4), columns=lrange(5))
+                       index=range(4), columns=range(5))
 
         dm.xs(2)[:] = 10
         assert (dm.xs(2) == 10).all()
@@ -2534,7 +2533,7 @@ def test_index_namedtuple(self):
         assert result == 1
 
     def test_boolean_indexing(self):
-        idx = lrange(3)
+        idx = list(range(3))
         cols = ['A', 'B', 'C']
         df1 = DataFrame(index=idx, columns=cols,
                         data=np.array([[0.0, 0.5, 1.0],
diff --git a/pandas/tests/frame/test_missing.py b/pandas/tests/frame/test_missing.py
index 07cd162905d6f..191972463f9af 100644
--- a/pandas/tests/frame/test_missing.py
+++ b/pandas/tests/frame/test_missing.py
@@ -4,7 +4,6 @@
 import numpy as np
 import pytest
 
-from pandas.compat import lrange
 import pandas.util._test_decorators as td
 
 import pandas as pd
@@ -83,7 +82,7 @@ def test_dropna(self):
         assert_frame_equal(inp, expected)
 
         dropped = df.dropna(axis=0)
-        expected = df.loc[lrange(2, 6)]
+        expected = df.loc[list(range(2, 6))]
         inp = df.copy()
         inp.dropna(axis=0, inplace=True)
         assert_frame_equal(dropped, expected)
@@ -98,7 +97,7 @@ def test_dropna(self):
         assert_frame_equal(inp, expected)
 
         dropped = df.dropna(axis=0, thresh=4)
-        expected = df.loc[lrange(2, 6)]
+        expected = df.loc[range(2, 6)]
         inp = df.copy()
         inp.dropna(axis=0, thresh=4, inplace=True)
         assert_frame_equal(dropped, expected)
@@ -414,9 +413,9 @@ def test_fillna_dtype_conversion(self):
         assert_series_equal(result, expected)
 
         # empty block
-        df = DataFrame(index=lrange(3), columns=['A', 'B'], dtype='float64')
+        df = DataFrame(index=range(3), columns=['A', 'B'], dtype='float64')
         result = df.fillna('nan')
-        expected = DataFrame('nan', index=lrange(3), columns=['A', 'B'])
+        expected = DataFrame('nan', index=range(3), columns=['A', 'B'])
         assert_frame_equal(result, expected)
 
         # equiv of replace
@@ -616,7 +615,7 @@ def test_fillna_invalid_value(self, float_frame):
     def test_fillna_col_reordering(self):
         cols = ["COL." + str(i) for i in range(5, 0, -1)]
         data = np.random.rand(20, 5)
-        df = DataFrame(index=lrange(20), columns=cols, data=data)
+        df = DataFrame(index=range(20), columns=cols, data=data)
         filled = df.fillna(method='ffill')
         assert df.columns.tolist() == filled.columns.tolist()
 
diff --git a/pandas/tests/frame/test_mutate_columns.py b/pandas/tests/frame/test_mutate_columns.py
index 5184eb42c0ec7..26267a64f9a4a 100644
--- a/pandas/tests/frame/test_mutate_columns.py
+++ b/pandas/tests/frame/test_mutate_columns.py
@@ -1,7 +1,7 @@
 import numpy as np
 import pytest
 
-from pandas.compat import PY36, lrange
+from pandas.compat import PY36
 
 from pandas import DataFrame, Index, MultiIndex, Series
 import pandas.util.testing as tm
@@ -133,12 +133,12 @@ def test_insert_benchmark(self):
         # from the vb_suite/frame_methods/frame_insert_columns
         N = 10
         K = 5
-        df = DataFrame(index=lrange(N))
+        df = DataFrame(index=range(N))
         new_col = np.random.randn(N)
         for i in range(K):
             df[i] = new_col
         expected = DataFrame(np.repeat(new_col, K).reshape(N, K),
-                             index=lrange(N))
+                             index=range(N))
         assert_frame_equal(df, expected)
 
     def test_insert(self):
diff --git a/pandas/tests/frame/test_nonunique_indexes.py b/pandas/tests/frame/test_nonunique_indexes.py
index 3315b17336d7b..d46ce41fc7f03 100644
--- a/pandas/tests/frame/test_nonunique_indexes.py
+++ b/pandas/tests/frame/test_nonunique_indexes.py
@@ -1,8 +1,6 @@
 import numpy as np
 import pytest
 
-from pandas.compat import lrange
-
 import pandas as pd
 from pandas import DataFrame, MultiIndex, Series, date_range
 from pandas.tests.frame.common import TestData
@@ -23,7 +21,7 @@ def check(result, expected=None):
         # assignment
         # GH 3687
         arr = np.random.randn(3, 2)
-        idx = lrange(2)
+        idx = list(range(2))
         df = DataFrame(arr, columns=['A', 'A'])
         df.columns = idx
         expected = DataFrame(arr, columns=idx)
diff --git a/pandas/tests/frame/test_replace.py b/pandas/tests/frame/test_replace.py
index 05019099b6fd6..2513508822fec 100644
--- a/pandas/tests/frame/test_replace.py
+++ b/pandas/tests/frame/test_replace.py
@@ -1,18 +1,32 @@
 from datetime import datetime
 from io import StringIO
 import re
+from typing import Dict
 
 import numpy as np
 import pytest
 
-from pandas.compat import lrange
-
 import pandas as pd
 from pandas import DataFrame, Index, Series, Timestamp, date_range
 from pandas.tests.frame.common import TestData
 from pandas.util.testing import assert_frame_equal, assert_series_equal
 
 
+@pytest.fixture
+def mix_ab() -> Dict[str, list]:
+    return {'a': list(range(4)),
+            'b': list('ab..'),
+            }
+
+
+@pytest.fixture
+def mix_abc() -> Dict[str, list]:
+    return {'a': list(range(4)),
+            'b': list('ab..'),
+            'c': ['a', 'b', np.nan, 'd'],
+            }
+
+
 class TestDataFrameReplace(TestData):
 
     def test_replace_inplace(self):
@@ -36,11 +50,10 @@ def test_replace_inplace(self):
         tsframe.replace([np.nan], [0], inplace=True)
         assert_frame_equal(tsframe, self.tsframe.fillna(0))
 
-    def test_regex_replace_scalar(self):
+    def test_regex_replace_scalar(self, mix_ab):
         obj = {'a': list('ab..'), 'b': list('efgh')}
         dfobj = DataFrame(obj)
-        mix = {'a': lrange(4), 'b': list('ab..')}
-        dfmix = DataFrame(mix)
+        dfmix = DataFrame(mix_ab)
 
         # simplest cases
         # regex -> value
@@ -62,7 +75,7 @@ def test_regex_replace_scalar(self):
 
         # with mixed
         res = dfmix.replace(r'\s*(\.)\s*', r'\1\1\1', regex=True)
-        mixc = mix.copy()
+        mixc = mix_ab.copy()
         mixc['b'] = ['a', 'b', '...', '...']
         expec = DataFrame(mixc)
         assert_frame_equal(res, expec)
@@ -85,28 +98,27 @@ def test_regex_replace_scalar(self):
 
         # with mixed
         res = dfmix.replace(re.compile(r'\s*(\.)\s*'), r'\1\1\1')
-        mixc = mix.copy()
+        mixc = mix_ab.copy()
         mixc['b'] = ['a', 'b', '...', '...']
         expec = DataFrame(mixc)
         assert_frame_equal(res, expec)
 
         res = dfmix.replace(regex=re.compile(r'\s*(\.)\s*'), value=r'\1\1\1')
-        mixc = mix.copy()
+        mixc = mix_ab.copy()
         mixc['b'] = ['a', 'b', '...', '...']
         expec = DataFrame(mixc)
         assert_frame_equal(res, expec)
 
         res = dfmix.replace(regex=r'\s*(\.)\s*', value=r'\1\1\1')
-        mixc = mix.copy()
+        mixc = mix_ab.copy()
         mixc['b'] = ['a', 'b', '...', '...']
         expec = DataFrame(mixc)
         assert_frame_equal(res, expec)
 
-    def test_regex_replace_scalar_inplace(self):
+    def test_regex_replace_scalar_inplace(self, mix_ab):
         obj = {'a': list('ab..'), 'b': list('efgh')}
         dfobj = DataFrame(obj)
-        mix = {'a': lrange(4), 'b': list('ab..')}
-        dfmix = DataFrame(mix)
+        dfmix = DataFrame(mix_ab)
 
         # simplest cases
         # regex -> value
@@ -132,7 +144,7 @@ def test_regex_replace_scalar_inplace(self):
         # with mixed
         res = dfmix.copy()
         res.replace(r'\s*(\.)\s*', r'\1\1\1', regex=True, inplace=True)
-        mixc = mix.copy()
+        mixc = mix_ab.copy()
         mixc['b'] = ['a', 'b', '...', '...']
         expec = DataFrame(mixc)
         assert_frame_equal(res, expec)
@@ -161,7 +173,7 @@ def test_regex_replace_scalar_inplace(self):
         res = dfmix.copy()
         res.replace(re.compile(r'\s*(\.)\s*'), r'\1\1\1', regex=True,
                     inplace=True)
-        mixc = mix.copy()
+        mixc = mix_ab.copy()
         mixc['b'] = ['a', 'b', '...', '...']
         expec = DataFrame(mixc)
         assert_frame_equal(res, expec)
@@ -187,7 +199,7 @@ def test_regex_replace_scalar_inplace(self):
         # with mixed
         res = dfmix.copy()
         res.replace(regex=r'\s*(\.)\s*', value=r'\1\1\1', inplace=True)
-        mixc = mix.copy()
+        mixc = mix_ab.copy()
         mixc['b'] = ['a', 'b', '...', '...']
         expec = DataFrame(mixc)
         assert_frame_equal(res, expec)
@@ -216,7 +228,7 @@ def test_regex_replace_scalar_inplace(self):
         res = dfmix.copy()
         res.replace(regex=re.compile(r'\s*(\.)\s*'), value=r'\1\1\1',
                     inplace=True)
-        mixc = mix.copy()
+        mixc = mix_ab.copy()
         mixc['b'] = ['a', 'b', '...', '...']
         expec = DataFrame(mixc)
         assert_frame_equal(res, expec)
@@ -230,19 +242,20 @@ def test_regex_replace_list_obj(self):
         to_replace_res = [r'\s*\.\s*', r'e|f|g']
         values = [np.nan, 'crap']
         res = dfobj.replace(to_replace_res, values, regex=True)
-        expec = DataFrame({'a': ['a', 'b', np.nan, np.nan], 'b': ['crap'] * 3 +
-                           ['h'], 'c': ['h', 'crap', 'l', 'o']})
+        expec = DataFrame({'a': ['a', 'b', np.nan, np.nan],
+                           'b': ['crap'] * 3 + ['h'],
+                           'c': ['h', 'crap', 'l', 'o'],
+                           })
         assert_frame_equal(res, expec)
 
         # list of [re1, re2, ..., reN] -> [re1, re2, .., reN]
         to_replace_res = [r'\s*(\.)\s*', r'(e|f|g)']
         values = [r'\1\1', r'\1_crap']
         res = dfobj.replace(to_replace_res, values, regex=True)
-        expec = DataFrame({'a': ['a', 'b', '..', '..'], 'b': ['e_crap',
-                                                              'f_crap',
-                                                              'g_crap', 'h'],
-                           'c': ['h', 'e_crap', 'l', 'o']})
-
+        expec = DataFrame({'a': ['a', 'b', '..', '..'],
+                           'b': ['e_crap', 'f_crap', 'g_crap', 'h'],
+                           'c': ['h', 'e_crap', 'l', 'o'],
+                           })
         assert_frame_equal(res, expec)
 
         # list of [re1, re2, ..., reN] -> [(re1 or v1), (re2 or v2), ..., (reN
@@ -250,17 +263,19 @@ def test_regex_replace_list_obj(self):
         to_replace_res = [r'\s*(\.)\s*', r'e']
         values = [r'\1\1', r'crap']
         res = dfobj.replace(to_replace_res, values, regex=True)
-        expec = DataFrame({'a': ['a', 'b', '..', '..'], 'b': ['crap', 'f', 'g',
-                                                              'h'],
-                           'c': ['h', 'crap', 'l', 'o']})
+        expec = DataFrame({'a': ['a', 'b', '..', '..'],
+                           'b': ['crap', 'f', 'g', 'h'],
+                           'c': ['h', 'crap', 'l', 'o'],
+                           })
         assert_frame_equal(res, expec)
 
         to_replace_res = [r'\s*(\.)\s*', r'e']
         values = [r'\1\1', r'crap']
         res = dfobj.replace(value=values, regex=to_replace_res)
-        expec = DataFrame({'a': ['a', 'b', '..', '..'], 'b': ['crap', 'f', 'g',
-                                                              'h'],
-                           'c': ['h', 'crap', 'l', 'o']})
+        expec = DataFrame({'a': ['a', 'b', '..', '..'],
+                           'b': ['crap', 'f', 'g', 'h'],
+                           'c': ['h', 'crap', 'l', 'o'],
+                           })
         assert_frame_equal(res, expec)
 
     def test_regex_replace_list_obj_inplace(self):
@@ -275,8 +290,10 @@ def test_regex_replace_list_obj_inplace(self):
         values = [np.nan, 'crap']
         res = dfobj.copy()
         res.replace(to_replace_res, values, inplace=True, regex=True)
-        expec = DataFrame({'a': ['a', 'b', np.nan, np.nan], 'b': ['crap'] * 3 +
-                           ['h'], 'c': ['h', 'crap', 'l', 'o']})
+        expec = DataFrame({'a': ['a', 'b', np.nan, np.nan],
+                           'b': ['crap'] * 3 + ['h'],
+                           'c': ['h', 'crap', 'l', 'o'],
+                           })
         assert_frame_equal(res, expec)
 
         # list of [re1, re2, ..., reN] -> [re1, re2, .., reN]
@@ -284,11 +301,10 @@ def test_regex_replace_list_obj_inplace(self):
         values = [r'\1\1', r'\1_crap']
         res = dfobj.copy()
         res.replace(to_replace_res, values, inplace=True, regex=True)
-        expec = DataFrame({'a': ['a', 'b', '..', '..'], 'b': ['e_crap',
-                                                              'f_crap',
-                                                              'g_crap', 'h'],
-                           'c': ['h', 'e_crap', 'l', 'o']})
-
+        expec = DataFrame({'a': ['a', 'b', '..', '..'],
+                           'b': ['e_crap', 'f_crap', 'g_crap', 'h'],
+                           'c': ['h', 'e_crap', 'l', 'o'],
+                           })
         assert_frame_equal(res, expec)
 
         # list of [re1, re2, ..., reN] -> [(re1 or v1), (re2 or v2), ..., (reN
@@ -297,43 +313,46 @@ def test_regex_replace_list_obj_inplace(self):
         values = [r'\1\1', r'crap']
         res = dfobj.copy()
         res.replace(to_replace_res, values, inplace=True, regex=True)
-        expec = DataFrame({'a': ['a', 'b', '..', '..'], 'b': ['crap', 'f', 'g',
-                                                              'h'],
-                           'c': ['h', 'crap', 'l', 'o']})
+        expec = DataFrame({'a': ['a', 'b', '..', '..'],
+                           'b': ['crap', 'f', 'g', 'h'],
+                           'c': ['h', 'crap', 'l', 'o'],
+                           })
         assert_frame_equal(res, expec)
 
         to_replace_res = [r'\s*(\.)\s*', r'e']
         values = [r'\1\1', r'crap']
         res = dfobj.copy()
         res.replace(value=values, regex=to_replace_res, inplace=True)
-        expec = DataFrame({'a': ['a', 'b', '..', '..'], 'b': ['crap', 'f', 'g',
-                                                              'h'],
-                           'c': ['h', 'crap', 'l', 'o']})
+        expec = DataFrame({'a': ['a', 'b', '..', '..'],
+                           'b': ['crap', 'f', 'g', 'h'],
+                           'c': ['h', 'crap', 'l', 'o'],
+                           })
         assert_frame_equal(res, expec)
 
-    def test_regex_replace_list_mixed(self):
+    def test_regex_replace_list_mixed(self, mix_ab):
         # mixed frame to make sure this doesn't break things
-        mix = {'a': lrange(4), 'b': list('ab..')}
-        dfmix = DataFrame(mix)
+        dfmix = DataFrame(mix_ab)
 
         # lists of regexes and values
         # list of [re1, re2, ..., reN] -> [v1, v2, ..., vN]
         to_replace_res = [r'\s*\.\s*', r'a']
         values = [np.nan, 'crap']
-        mix2 = {'a': lrange(4), 'b': list('ab..'), 'c': list('halo')}
+        mix2 = {'a': list(range(4)), 'b': list('ab..'), 'c': list('halo')}
         dfmix2 = DataFrame(mix2)
         res = dfmix2.replace(to_replace_res, values, regex=True)
-        expec = DataFrame({'a': mix2['a'], 'b': ['crap', 'b', np.nan, np.nan],
-                           'c': ['h', 'crap', 'l', 'o']})
+        expec = DataFrame({'a': mix2['a'],
+                           'b': ['crap', 'b', np.nan, np.nan],
+                           'c': ['h', 'crap', 'l', 'o'],
+                           })
         assert_frame_equal(res, expec)
 
         # list of [re1, re2, ..., reN] -> [re1, re2, .., reN]
         to_replace_res = [r'\s*(\.)\s*', r'(a|b)']
         values = [r'\1\1', r'\1_crap']
         res = dfmix.replace(to_replace_res, values, regex=True)
-        expec = DataFrame({'a': mix['a'], 'b': ['a_crap', 'b_crap', '..',
-                                                '..']})
-
+        expec = DataFrame({'a': mix_ab['a'],
+                           'b': ['a_crap', 'b_crap', '..', '..'],
+                           })
         assert_frame_equal(res, expec)
 
         # list of [re1, re2, ..., reN] -> [(re1 or v1), (re2 or v2), ..., (reN
@@ -341,18 +360,21 @@ def test_regex_replace_list_mixed(self):
         to_replace_res = [r'\s*(\.)\s*', r'a', r'(b)']
         values = [r'\1\1', r'crap', r'\1_crap']
         res = dfmix.replace(to_replace_res, values, regex=True)
-        expec = DataFrame({'a': mix['a'], 'b': ['crap', 'b_crap', '..', '..']})
+        expec = DataFrame({'a': mix_ab['a'],
+                           'b': ['crap', 'b_crap', '..', '..'],
+                           })
         assert_frame_equal(res, expec)
 
         to_replace_res = [r'\s*(\.)\s*', r'a', r'(b)']
         values = [r'\1\1', r'crap', r'\1_crap']
         res = dfmix.replace(regex=to_replace_res, value=values)
-        expec = DataFrame({'a': mix['a'], 'b': ['crap', 'b_crap', '..', '..']})
+        expec = DataFrame({'a': mix_ab['a'],
+                           'b': ['crap', 'b_crap', '..', '..'],
+                           })
         assert_frame_equal(res, expec)
 
-    def test_regex_replace_list_mixed_inplace(self):
-        mix = {'a': lrange(4), 'b': list('ab..')}
-        dfmix = DataFrame(mix)
+    def test_regex_replace_list_mixed_inplace(self, mix_ab):
+        dfmix = DataFrame(mix_ab)
         # the same inplace
         # lists of regexes and values
         # list of [re1, re2, ..., reN] -> [v1, v2, ..., vN]
@@ -360,7 +382,9 @@ def test_regex_replace_list_mixed_inplace(self):
         values = [np.nan, 'crap']
         res = dfmix.copy()
         res.replace(to_replace_res, values, inplace=True, regex=True)
-        expec = DataFrame({'a': mix['a'], 'b': ['crap', 'b', np.nan, np.nan]})
+        expec = DataFrame({'a': mix_ab['a'],
+                           'b': ['crap', 'b', np.nan, np.nan],
+                           })
         assert_frame_equal(res, expec)
 
         # list of [re1, re2, ..., reN] -> [re1, re2, .., reN]
@@ -368,9 +392,9 @@ def test_regex_replace_list_mixed_inplace(self):
         values = [r'\1\1', r'\1_crap']
         res = dfmix.copy()
         res.replace(to_replace_res, values, inplace=True, regex=True)
-        expec = DataFrame({'a': mix['a'], 'b': ['a_crap', 'b_crap', '..',
-                                                '..']})
-
+        expec = DataFrame({'a': mix_ab['a'],
+                           'b': ['a_crap', 'b_crap', '..', '..'],
+                           })
         assert_frame_equal(res, expec)
 
         # list of [re1, re2, ..., reN] -> [(re1 or v1), (re2 or v2), ..., (reN
@@ -379,19 +403,22 @@ def test_regex_replace_list_mixed_inplace(self):
         values = [r'\1\1', r'crap', r'\1_crap']
         res = dfmix.copy()
         res.replace(to_replace_res, values, inplace=True, regex=True)
-        expec = DataFrame({'a': mix['a'], 'b': ['crap', 'b_crap', '..', '..']})
+        expec = DataFrame({'a': mix_ab['a'],
+                           'b': ['crap', 'b_crap', '..', '..'],
+                           })
         assert_frame_equal(res, expec)
 
         to_replace_res = [r'\s*(\.)\s*', r'a', r'(b)']
         values = [r'\1\1', r'crap', r'\1_crap']
         res = dfmix.copy()
         res.replace(regex=to_replace_res, value=values, inplace=True)
-        expec = DataFrame({'a': mix['a'], 'b': ['crap', 'b_crap', '..', '..']})
+        expec = DataFrame({'a': mix_ab['a'],
+                           'b': ['crap', 'b_crap', '..', '..'],
+                           })
         assert_frame_equal(res, expec)
 
-    def test_regex_replace_dict_mixed(self):
-        mix = {'a': lrange(4), 'b': list('ab..'), 'c': ['a', 'b', np.nan, 'd']}
-        dfmix = DataFrame(mix)
+    def test_regex_replace_dict_mixed(self, mix_abc):
+        dfmix = DataFrame(mix_abc)
 
         # dicts
         # single dict {re1: v1}, search the whole frame
@@ -403,8 +430,10 @@ def test_regex_replace_dict_mixed(self):
         res2 = dfmix.copy()
         res2.replace({'b': r'\s*\.\s*'}, {'b': np.nan},
                      inplace=True, regex=True)
-        expec = DataFrame({'a': mix['a'], 'b': ['a', 'b', np.nan, np.nan], 'c':
-                           mix['c']})
+        expec = DataFrame({'a': mix_abc['a'],
+                           'b': ['a', 'b', np.nan, np.nan],
+                           'c': mix_abc['c'],
+                           })
         assert_frame_equal(res, expec)
         assert_frame_equal(res2, expec)
 
@@ -414,8 +443,10 @@ def test_regex_replace_dict_mixed(self):
         res2 = dfmix.copy()
         res2.replace({'b': r'\s*(\.)\s*'}, {'b': r'\1ty'}, inplace=True,
                      regex=True)
-        expec = DataFrame({'a': mix['a'], 'b': ['a', 'b', '.ty', '.ty'], 'c':
-                           mix['c']})
+        expec = DataFrame({'a': mix_abc['a'],
+                           'b': ['a', 'b', '.ty', '.ty'],
+                           'c': mix_abc['c'],
+                           })
         assert_frame_equal(res, expec)
         assert_frame_equal(res2, expec)
 
@@ -423,15 +454,19 @@ def test_regex_replace_dict_mixed(self):
         res2 = dfmix.copy()
         res2.replace(regex={'b': r'\s*(\.)\s*'}, value={'b': r'\1ty'},
                      inplace=True)
-        expec = DataFrame({'a': mix['a'], 'b': ['a', 'b', '.ty', '.ty'], 'c':
-                           mix['c']})
+        expec = DataFrame({'a': mix_abc['a'],
+                           'b': ['a', 'b', '.ty', '.ty'],
+                           'c': mix_abc['c'],
+                           })
         assert_frame_equal(res, expec)
         assert_frame_equal(res2, expec)
 
         # scalar -> dict
         # to_replace regex, {value: value}
-        expec = DataFrame({'a': mix['a'], 'b': [np.nan, 'b', '.', '.'], 'c':
-                           mix['c']})
+        expec = DataFrame({'a': mix_abc['a'],
+                           'b': [np.nan, 'b', '.', '.'],
+                           'c': mix_abc['c'],
+                           })
         res = dfmix.replace('a', {'b': np.nan}, regex=True)
         res2 = dfmix.copy()
         res2.replace('a', {'b': np.nan}, regex=True, inplace=True)
@@ -441,23 +476,26 @@ def test_regex_replace_dict_mixed(self):
         res = dfmix.replace('a', {'b': np.nan}, regex=True)
         res2 = dfmix.copy()
         res2.replace(regex='a', value={'b': np.nan}, inplace=True)
-        expec = DataFrame({'a': mix['a'], 'b': [np.nan, 'b', '.', '.'], 'c':
-                           mix['c']})
+        expec = DataFrame({'a': mix_abc['a'],
+                           'b': [np.nan, 'b', '.', '.'],
+                           'c': mix_abc['c'],
+                           })
         assert_frame_equal(res, expec)
         assert_frame_equal(res2, expec)
 
-    def test_regex_replace_dict_nested(self):
+    def test_regex_replace_dict_nested(self, mix_abc):
         # nested dicts will not work until this is implemented for Series
-        mix = {'a': lrange(4), 'b': list('ab..'), 'c': ['a', 'b', np.nan, 'd']}
-        dfmix = DataFrame(mix)
+        dfmix = DataFrame(mix_abc)
         res = dfmix.replace({'b': {r'\s*\.\s*': np.nan}}, regex=True)
         res2 = dfmix.copy()
         res4 = dfmix.copy()
         res2.replace({'b': {r'\s*\.\s*': np.nan}}, inplace=True, regex=True)
         res3 = dfmix.replace(regex={'b': {r'\s*\.\s*': np.nan}})
         res4.replace(regex={'b': {r'\s*\.\s*': np.nan}}, inplace=True)
-        expec = DataFrame({'a': mix['a'], 'b': ['a', 'b', np.nan, np.nan], 'c':
-                           mix['c']})
+        expec = DataFrame({'a': mix_abc['a'],
+                           'b': ['a', 'b', np.nan, np.nan],
+                           'c': mix_abc['c'],
+                           })
         assert_frame_equal(res, expec)
         assert_frame_equal(res2, expec)
         assert_frame_equal(res3, expec)
@@ -476,12 +514,12 @@ def test_regex_replace_dict_nested_gh4115(self):
         result = df.replace({'Type': {'Q': 0, 'T': 1}})
         assert_frame_equal(result, expected)
 
-    def test_regex_replace_list_to_scalar(self):
-        mix = {'a': lrange(4), 'b': list('ab..'), 'c': ['a', 'b', np.nan, 'd']}
-        df = DataFrame(mix)
-        expec = DataFrame({'a': mix['a'], 'b': np.array([np.nan] * 4),
-                           'c': [np.nan, np.nan, np.nan, 'd']})
-
+    def test_regex_replace_list_to_scalar(self, mix_abc):
+        df = DataFrame(mix_abc)
+        expec = DataFrame({'a': mix_abc['a'],
+                           'b': np.array([np.nan] * 4),
+                           'c': [np.nan, np.nan, np.nan, 'd'],
+                           })
         res = df.replace([r'\s*\.\s*', 'a|b'], np.nan, regex=True)
         res2 = df.copy()
         res3 = df.copy()
@@ -491,39 +529,39 @@ def test_regex_replace_list_to_scalar(self):
         assert_frame_equal(res2, expec)
         assert_frame_equal(res3, expec)
 
-    def test_regex_replace_str_to_numeric(self):
+    def test_regex_replace_str_to_numeric(self, mix_abc):
         # what happens when you try to replace a numeric value with a regex?
-        mix = {'a': lrange(4), 'b': list('ab..'), 'c': ['a', 'b', np.nan, 'd']}
-        df = DataFrame(mix)
+        df = DataFrame(mix_abc)
         res = df.replace(r'\s*\.\s*', 0, regex=True)
         res2 = df.copy()
         res2.replace(r'\s*\.\s*', 0, inplace=True, regex=True)
         res3 = df.copy()
         res3.replace(regex=r'\s*\.\s*', value=0, inplace=True)
-        expec = DataFrame({'a': mix['a'], 'b': ['a', 'b', 0, 0], 'c':
-                           mix['c']})
+        expec = DataFrame({'a': mix_abc['a'],
+                           'b': ['a', 'b', 0, 0],
+                           'c': mix_abc['c'],
+                           })
         assert_frame_equal(res, expec)
         assert_frame_equal(res2, expec)
         assert_frame_equal(res3, expec)
 
-    def test_regex_replace_regex_list_to_numeric(self):
-        mix = {'a': lrange(4), 'b': list('ab..'), 'c': ['a', 'b', np.nan, 'd']}
-        df = DataFrame(mix)
+    def test_regex_replace_regex_list_to_numeric(self, mix_abc):
+        df = DataFrame(mix_abc)
         res = df.replace([r'\s*\.\s*', 'b'], 0, regex=True)
         res2 = df.copy()
         res2.replace([r'\s*\.\s*', 'b'], 0, regex=True, inplace=True)
         res3 = df.copy()
         res3.replace(regex=[r'\s*\.\s*', 'b'], value=0, inplace=True)
-        expec = DataFrame({'a': mix['a'], 'b': ['a', 0, 0, 0], 'c': ['a', 0,
-                                                                     np.nan,
-                                                                     'd']})
+        expec = DataFrame({'a': mix_abc['a'],
+                           'b': ['a', 0, 0, 0],
+                           'c': ['a', 0, np.nan, 'd'],
+                           })
         assert_frame_equal(res, expec)
         assert_frame_equal(res2, expec)
         assert_frame_equal(res3, expec)
 
-    def test_regex_replace_series_of_regexes(self):
-        mix = {'a': lrange(4), 'b': list('ab..'), 'c': ['a', 'b', np.nan, 'd']}
-        df = DataFrame(mix)
+    def test_regex_replace_series_of_regexes(self, mix_abc):
+        df = DataFrame(mix_abc)
         s1 = Series({'b': r'\s*\.\s*'})
         s2 = Series({'b': np.nan})
         res = df.replace(s1, s2, regex=True)
@@ -531,16 +569,20 @@ def test_regex_replace_series_of_regexes(self):
         res2.replace(s1, s2, inplace=True, regex=True)
         res3 = df.copy()
         res3.replace(regex=s1, value=s2, inplace=True)
-        expec = DataFrame({'a': mix['a'], 'b': ['a', 'b', np.nan, np.nan], 'c':
-                           mix['c']})
+        expec = DataFrame({'a': mix_abc['a'],
+                           'b': ['a', 'b', np.nan, np.nan],
+                           'c': mix_abc['c'],
+                           })
         assert_frame_equal(res, expec)
         assert_frame_equal(res2, expec)
         assert_frame_equal(res3, expec)
 
-    def test_regex_replace_numeric_to_object_conversion(self):
-        mix = {'a': lrange(4), 'b': list('ab..'), 'c': ['a', 'b', np.nan, 'd']}
-        df = DataFrame(mix)
-        expec = DataFrame({'a': ['a', 1, 2, 3], 'b': mix['b'], 'c': mix['c']})
+    def test_regex_replace_numeric_to_object_conversion(self, mix_abc):
+        df = DataFrame(mix_abc)
+        expec = DataFrame({'a': ['a', 1, 2, 3],
+                           'b': mix_abc['b'],
+                           'c': mix_abc['c'],
+                           })
         res = df.replace(0, 'a')
         assert_frame_equal(res, expec)
         assert res.a.dtype == np.object_
@@ -587,18 +629,19 @@ def test_replace_list(self):
         values = [np.nan, 'crap']
         res = dfobj.replace(to_replace_res, values)
         expec = DataFrame({'a': ['a', 'b', np.nan, np.nan],
-                           'b': ['crap', 'f', 'g', 'h'], 'c': ['h', 'crap',
-                                                               'l', 'o']})
+                           'b': ['crap', 'f', 'g', 'h'],
+                           'c': ['h', 'crap', 'l', 'o'],
+                           })
         assert_frame_equal(res, expec)
 
         # list of [v1, v2, ..., vN] -> [v1, v2, .., vN]
         to_replace_res = [r'.', r'f']
         values = [r'..', r'crap']
         res = dfobj.replace(to_replace_res, values)
-        expec = DataFrame({'a': ['a', 'b', '..', '..'], 'b': ['e', 'crap', 'g',
-                                                              'h'],
-                           'c': ['h', 'e', 'l', 'o']})
-
+        expec = DataFrame({'a': ['a', 'b', '..', '..'],
+                           'b': ['e', 'crap', 'g', 'h'],
+                           'c': ['h', 'e', 'l', 'o'],
+                           })
         assert_frame_equal(res, expec)
 
     def test_replace_with_empty_list(self):
@@ -929,7 +972,7 @@ def test_replace_truthy(self):
         assert_frame_equal(r, e)
 
     def test_replace_int_to_int_chain(self):
-        df = DataFrame({'a': lrange(1, 5)})
+        df = DataFrame({'a': list(range(1, 5))})
         with pytest.raises(ValueError, match="Replacement not allowed .+"):
             df.replace({'a': dict(zip(range(1, 5), range(2, 6)))})
 
@@ -1065,10 +1108,9 @@ def test_replace_datetimetz(self):
                               'B': [0, np.nan, 2]})
         assert_frame_equal(result, expected)
 
-    def test_replace_with_empty_dictlike(self):
+    def test_replace_with_empty_dictlike(self, mix_abc):
         # GH 15289
-        mix = {'a': lrange(4), 'b': list('ab..'), 'c': ['a', 'b', np.nan, 'd']}
-        df = DataFrame(mix)
+        df = DataFrame(mix_abc)
         assert_frame_equal(df, df.replace({}))
         assert_frame_equal(df, df.replace(Series([])))
 
diff --git a/pandas/tests/frame/test_repr_info.py b/pandas/tests/frame/test_repr_info.py
index f5ec4429c4df5..044160ac6f5e8 100644
--- a/pandas/tests/frame/test_repr_info.py
+++ b/pandas/tests/frame/test_repr_info.py
@@ -7,7 +7,7 @@
 import numpy as np
 import pytest
 
-from pandas.compat import PYPY, lrange
+from pandas.compat import PYPY
 
 import pandas as pd
 from pandas import (
@@ -43,7 +43,7 @@ def test_repr_mixed_big(self):
         # big mixed
         biggie = DataFrame({'A': np.random.randn(200),
                             'B': tm.makeStringIndex(200)},
-                           index=lrange(200))
+                           index=range(200))
         biggie.loc[:20, 'A'] = np.nan
         biggie.loc[:20, 'B'] = np.nan
 
@@ -88,8 +88,8 @@ def test_repr_dimensions(self):
     @pytest.mark.slow
     def test_repr_big(self):
         # big one
-        biggie = DataFrame(np.zeros((200, 4)), columns=lrange(4),
-                           index=lrange(200))
+        biggie = DataFrame(np.zeros((200, 4)), columns=range(4),
+                           index=range(200))
         repr(biggie)
 
     def test_repr_unsortable(self):
diff --git a/pandas/tests/frame/test_sorting.py b/pandas/tests/frame/test_sorting.py
index 98196e1ad12ae..246ba943a4509 100644
--- a/pandas/tests/frame/test_sorting.py
+++ b/pandas/tests/frame/test_sorting.py
@@ -3,8 +3,6 @@
 import numpy as np
 import pytest
 
-from pandas.compat import lrange
-
 import pandas as pd
 from pandas import (
     Categorical, DataFrame, IntervalIndex, MultiIndex, NaT, Series, Timestamp,
@@ -442,7 +440,7 @@ def test_sort_index_duplicates(self):
 
         # with 9816, these are all translated to .sort_values
 
-        df = DataFrame([lrange(5, 9), lrange(4)],
+        df = DataFrame([range(5, 9), range(4)],
                        columns=['a', 'a', 'b', 'b'])
 
         with pytest.raises(ValueError, match='not unique'):
diff --git a/pandas/tests/frame/test_timezones.py b/pandas/tests/frame/test_timezones.py
index 0a4dee2bdd534..5b2f846eccdd5 100644
--- a/pandas/tests/frame/test_timezones.py
+++ b/pandas/tests/frame/test_timezones.py
@@ -7,8 +7,6 @@
 import pytest
 import pytz
 
-from pandas.compat import lrange
-
 from pandas.core.dtypes.dtypes import DatetimeTZDtype
 
 import pandas as pd
@@ -94,7 +92,7 @@ def test_frame_join_tzaware(self):
         test2 = DataFrame(np.zeros((3, 3)),
                           index=date_range("2012-11-15 00:00:00", periods=3,
                                            freq="250L", tz="US/Central"),
-                          columns=lrange(3, 6))
+                          columns=range(3, 6))
 
         result = test1.join(test2, how='outer')
         ex_index = test1.index.union(test2.index)
diff --git a/pandas/tests/io/formats/test_format.py b/pandas/tests/io/formats/test_format.py
index 90b638497d552..2779e3f56f923 100644
--- a/pandas/tests/io/formats/test_format.py
+++ b/pandas/tests/io/formats/test_format.py
@@ -18,7 +18,7 @@
 import pytest
 import pytz
 
-from pandas.compat import is_platform_32bit, is_platform_windows, lrange
+from pandas.compat import is_platform_32bit, is_platform_windows
 
 import pandas as pd
 from pandas import (
@@ -232,10 +232,10 @@ def test_repr_chop_threshold_column_below(self):
 
     def test_repr_obeys_max_seq_limit(self):
         with option_context("display.max_seq_items", 2000):
-            assert len(printing.pprint_thing(lrange(1000))) > 1000
+            assert len(printing.pprint_thing(list(range(1000)))) > 1000
 
         with option_context("display.max_seq_items", 5):
-            assert len(printing.pprint_thing(lrange(1000))) < 100
+            assert len(printing.pprint_thing(list(range(1000)))) < 100
 
     def test_repr_set(self):
         assert printing.pprint_thing({1}) == '{1}'
@@ -265,9 +265,9 @@ def test_repr_no_backslash(self):
             assert '\\' not in repr(df)
 
     def test_expand_frame_repr(self):
-        df_small = DataFrame('hello', [0], [0])
-        df_wide = DataFrame('hello', [0], lrange(10))
-        df_tall = DataFrame('hello', lrange(30), lrange(5))
+        df_small = DataFrame('hello', index=[0], columns=[0])
+        df_wide = DataFrame('hello', index=[0], columns=range(10))
+        df_tall = DataFrame('hello', index=range(30), columns=range(5))
 
         with option_context('mode.sim_interactive', True):
             with option_context('display.max_columns', 10, 'display.width', 20,
@@ -292,7 +292,7 @@ def test_expand_frame_repr(self):
     def test_repr_non_interactive(self):
         # in non interactive mode, there can be no dependency on the
         # result of terminal auto size detection
-        df = DataFrame('hello', lrange(1000), lrange(5))
+        df = DataFrame('hello', index=range(1000), columns=range(5))
 
         with option_context('mode.sim_interactive', False, 'display.width', 0,
                             'display.max_rows', 5000):
@@ -1175,7 +1175,7 @@ def test_to_string(self):
         # big mixed
         biggie = DataFrame({'A': np.random.randn(200),
                             'B': tm.makeStringIndex(200)},
-                           index=lrange(200))
+                           index=np.arange(200))
 
         biggie.loc[:20, 'A'] = np.nan
         biggie.loc[:20, 'B'] = np.nan
@@ -1357,7 +1357,7 @@ def test_to_string_small_float_values(self):
 
     def test_to_string_float_index(self):
         index = Index([1.5, 2, 3, 4, 5])
-        df = DataFrame(lrange(5), index=index)
+        df = DataFrame(np.arange(5), index=index)
 
         result = df.to_string()
         expected = ('     0\n'
@@ -1399,7 +1399,7 @@ def test_to_string_int_formatting(self):
         assert output == expected
 
     def test_to_string_index_formatter(self):
-        df = DataFrame([lrange(5), lrange(5, 10), lrange(10, 15)])
+        df = DataFrame([range(5), range(5, 10), range(10, 15)])
 
         rs = df.to_string(formatters={'__index__': lambda x: 'abc' [x]})
 
@@ -1485,12 +1485,12 @@ def test_to_string_decimal(self):
         assert df.to_string(decimal=',') == expected
 
     def test_to_string_line_width(self):
-        df = DataFrame(123, lrange(10, 15), lrange(30))
+        df = DataFrame(123, index=range(10, 15), columns=range(30))
         s = df.to_string(line_width=80)
         assert max(len(l) for l in s.split('\n')) == 80
 
     def test_show_dimensions(self):
-        df = DataFrame(123, lrange(10, 15), lrange(30))
+        df = DataFrame(123, index=range(10, 15), columns=range(30))
 
         with option_context('display.max_rows', 10, 'display.max_columns', 40,
                             'display.width', 500, 'display.expand_frame_repr',
diff --git a/pandas/tests/series/test_apply.py b/pandas/tests/series/test_apply.py
index b7f308c6f8630..ccd39f09c92e0 100644
--- a/pandas/tests/series/test_apply.py
+++ b/pandas/tests/series/test_apply.py
@@ -4,8 +4,6 @@
 import numpy as np
 import pytest
 
-from pandas.compat import lrange
-
 import pandas as pd
 from pandas import DataFrame, Index, Series, isna
 from pandas.conftest import _get_cython_table_params
@@ -500,7 +498,7 @@ def test_map_int(self):
         assert not isna(merged['c'])
 
     def test_map_type_inference(self):
-        s = Series(lrange(3))
+        s = Series(range(3))
         s2 = s.map(lambda x: np.where(x == 0, 0, 1))
         assert issubclass(s2.dtype.type, np.integer)
 
diff --git a/pandas/tests/series/test_constructors.py b/pandas/tests/series/test_constructors.py
index fd90a87c553c4..ad9b691e7a6d3 100644
--- a/pandas/tests/series/test_constructors.py
+++ b/pandas/tests/series/test_constructors.py
@@ -8,7 +8,7 @@
 
 from pandas._libs import lib
 from pandas._libs.tslib import iNaT
-from pandas.compat import PY36, lrange
+from pandas.compat import PY36
 
 from pandas.core.dtypes.common import (
     is_categorical_dtype, is_datetime64tz_dtype)
@@ -124,13 +124,13 @@ def test_constructor_empty(self, input_class):
 
         if input_class is not list:
             # With index:
-            empty = Series(index=lrange(10))
-            empty2 = Series(input_class(), index=lrange(10))
+            empty = Series(index=range(10))
+            empty2 = Series(input_class(), index=range(10))
             assert_series_equal(empty, empty2)
 
             # With index and dtype float64:
-            empty = Series(np.nan, index=lrange(10))
-            empty2 = Series(input_class(), index=lrange(10), dtype='float64')
+            empty = Series(np.nan, index=range(10))
+            empty2 = Series(input_class(), index=range(10), dtype='float64')
             assert_series_equal(empty, empty2)
 
             # GH 19853 : with empty string, index and dtype str
@@ -140,8 +140,8 @@ def test_constructor_empty(self, input_class):
 
     @pytest.mark.parametrize('input_arg', [np.nan, float('nan')])
     def test_constructor_nan(self, input_arg):
-        empty = Series(dtype='float64', index=lrange(10))
-        empty2 = Series(input_arg, index=lrange(10))
+        empty = Series(dtype='float64', index=range(10))
+        empty2 = Series(input_arg, index=range(10))
 
         assert_series_equal(empty, empty2, check_index_type=False)
 
@@ -250,12 +250,12 @@ def test_constructor_generator(self):
         gen = (i for i in range(10))
 
         result = Series(gen)
-        exp = Series(lrange(10))
+        exp = Series(range(10))
         assert_series_equal(result, exp)
 
         gen = (i for i in range(10))
-        result = Series(gen, index=lrange(10, 20))
-        exp.index = lrange(10, 20)
+        result = Series(gen, index=range(10, 20))
+        exp.index = range(10, 20)
         assert_series_equal(result, exp)
 
     def test_constructor_map(self):
@@ -263,12 +263,12 @@ def test_constructor_map(self):
         m = map(lambda x: x, range(10))
 
         result = Series(m)
-        exp = Series(lrange(10))
+        exp = Series(range(10))
         assert_series_equal(result, exp)
 
         m = map(lambda x: x, range(10))
-        result = Series(m, index=lrange(10, 20))
-        exp.index = lrange(10, 20)
+        result = Series(m, index=range(10, 20))
+        exp.index = range(10, 20)
         assert_series_equal(result, exp)
 
     def test_constructor_categorical(self):
@@ -574,10 +574,10 @@ def test_constructor_limit_copies(self, index):
         assert s._data.blocks[0].values is not index
 
     def test_constructor_pass_none(self):
-        s = Series(None, index=lrange(5))
+        s = Series(None, index=range(5))
         assert s.dtype == np.float64
 
-        s = Series(None, index=lrange(5), dtype=object)
+        s = Series(None, index=range(5), dtype=object)
         assert s.dtype == np.object_
 
         # GH 7431
@@ -670,15 +670,15 @@ def test_constructor_datetimes_with_nulls(self):
 
     def test_constructor_dtype_datetime64(self):
 
-        s = Series(iNaT, dtype='M8[ns]', index=lrange(5))
+        s = Series(iNaT, dtype='M8[ns]', index=range(5))
         assert isna(s).all()
 
         # in theory this should be all nulls, but since
         # we are not specifying a dtype is ambiguous
-        s = Series(iNaT, index=lrange(5))
+        s = Series(iNaT, index=range(5))
         assert not isna(s).all()
 
-        s = Series(nan, dtype='M8[ns]', index=lrange(5))
+        s = Series(nan, dtype='M8[ns]', index=range(5))
         assert isna(s).all()
 
         s = Series([datetime(2001, 1, 2, 0, 0), iNaT], dtype='M8[ns]')
diff --git a/pandas/tests/series/test_dtypes.py b/pandas/tests/series/test_dtypes.py
index 945b89e7c6f99..51334557fa403 100644
--- a/pandas/tests/series/test_dtypes.py
+++ b/pandas/tests/series/test_dtypes.py
@@ -7,7 +7,6 @@
 import pytest
 
 from pandas._libs.tslibs import iNaT
-from pandas.compat import lrange
 
 import pandas as pd
 from pandas import (
@@ -82,7 +81,7 @@ def test_astype_cast_object_int(self):
         tm.assert_series_equal(result, Series(np.arange(1, 5)))
 
     def test_astype_datetime(self):
-        s = Series(iNaT, dtype='M8[ns]', index=lrange(5))
+        s = Series(iNaT, dtype='M8[ns]', index=range(5))
 
         s = s.astype('O')
         assert s.dtype == np.object_
diff --git a/pandas/tests/series/test_timeseries.py b/pandas/tests/series/test_timeseries.py
index a817d79ec6e0d..97f1cd1cc7789 100644
--- a/pandas/tests/series/test_timeseries.py
+++ b/pandas/tests/series/test_timeseries.py
@@ -7,7 +7,6 @@
 
 from pandas._libs.tslib import iNaT
 from pandas._libs.tslibs.np_datetime import OutOfBoundsDatetime
-from pandas.compat import lrange
 from pandas.errors import NullFrequencyError
 import pandas.util._test_decorators as td
 
@@ -919,11 +918,11 @@ def test_groupby_count_dateparseerror(self):
         dr = date_range(start='1/1/2012', freq='5min', periods=10)
 
         # BAD Example, datetimes first
-        s = Series(np.arange(10), index=[dr, lrange(10)])
+        s = Series(np.arange(10), index=[dr, np.arange(10)])
         grouped = s.groupby(lambda x: x[1] % 2 == 0)
         result = grouped.count()
 
-        s = Series(np.arange(10), index=[lrange(10), dr])
+        s = Series(np.arange(10), index=[np.arange(10), dr])
         grouped = s.groupby(lambda x: x[0] % 2 == 0)
         expected = grouped.count()
 
diff --git a/pandas/tests/series/test_timezones.py b/pandas/tests/series/test_timezones.py
index 69f3509fbdc4f..6ff02b3160020 100644
--- a/pandas/tests/series/test_timezones.py
+++ b/pandas/tests/series/test_timezones.py
@@ -9,7 +9,6 @@
 import pytz
 
 from pandas._libs.tslibs import conversion, timezones
-from pandas.compat import lrange
 
 from pandas import DatetimeIndex, Index, NaT, Series, Timestamp
 from pandas.core.indexes.datetimes import date_range
@@ -194,7 +193,7 @@ def test_series_append_aware_naive(self):
 
         # mixed
         rng1 = date_range('1/1/2011 01:00', periods=1, freq='H')
-        rng2 = lrange(100)
+        rng2 = range(100)
         ser1 = Series(np.random.randn(len(rng1)), index=rng1)
         ser2 = Series(np.random.randn(len(rng2)), index=rng2)
         ts_result = ser1.append(ser2)