Mfcttrf

I implemented class Range as an equivalent to Python built-in range for practicing purposes. No features were added. Hope it mimics all aspects of range behavior, but maybe you can point out something I forgot. Also I tried to make the code efficient, that's why Range doesn't inherit from collections.abc.Sequence and doesn't use any of it's not abstract methods. All feedback on how to improve the code is welcome!

pyrange.py

"""
Pure Python implementation of built-in range
"""


import math
import collections.abc
import numbers


def interpret_as_integer(obj):
 if hasattr(obj, '__index__'):
 return obj.__index__()
 raise TypeError(
 ''' object cannot be interpreted as an integer'.format(
 type(obj).__name__
 )
 )


def adjust_indices(length, start, stop, step):
 if step is None:
 step = 1
 else:
 step = interpret_as_integer(step)

 if start is None:
 start = length - 1 if step < 0 else 0
 else:
 start = interpret_as_integer(start)
 if start < 0:
 start += length
 if start < 0:
 start = -1 if step < 0 else 0
 elif start >= length:
 start = length - 1 if step < 0 else length

 if stop is None:
 stop = -1 if step < 0 else length
 else:
 stop = interpret_as_integer(stop)
 if stop < 0:
 stop += length
 if stop < 0:
 stop = -1 if step < 0 else 0
 elif stop >= length:
 stop = length - 1 if step < 0 else length

 return start, stop, step


class Range:
 """
 Range(stop) -> Range object
 Range(start, stop[, step]) -> Range object

 Return an object that produces a sequence of integers from start (inclusive)
 to stop (exclusive) by step. Range(i, j) produces i, i+1, i+2, ..., j-1.
 start defaults to 0, and stop is omitted! Range(4) produces 0, 1, 2, 3.
 These are exactly the valid indices for a list of 4 elements.
 When step is given, it specifies the increment (or decrement).
 """

 __slots__ = ('start', 'stop', 'step', '_len')

 def __init__(self, start, stop=None, step=1):
 if stop is None:
 start, stop = 0, start
 self.start, self.stop, self.step = (
 interpret_as_integer(obj) for obj in (start, stop, step)
 )
 if step == 0:
 raise ValueError('Range() arg 3 must not be zero')
 step_sign = int(math.copysign(1, self.step))
 self._len = max(
 1 + (self.stop - self.start - step_sign) // self.step, 0
 )

 def __contains__(self, value):
 if isinstance(value, numbers.Integral):
 return self._index(value) != -1
 return any(n == value for n in self)

 def __eq__(self, other):
 if not isinstance(other, Range):
 return False
 if self._len != len(other):
 return False
 if self._len == 0:
 return True
 if self.start != other.start:
 return False
 if self[-1] == other[-1]:
 return True
 return False

 def __getitem__(self, index):
 if isinstance(index, slice):
 start, stop, step = adjust_indices(
 self._len, index.start, index.stop, index.step
 )
 return Range(
 self.start + self.step * start,
 self.start + self.step * stop,
 self.step * step
 )
 index = interpret_as_integer(index)
 if index < 0:
 index += self._len
 if not 0 <= index < self._len:
 raise IndexError('Range object index out of Range')
 return self.start + self.step * index

 def __hash__(self):
 if self._len == 0:
 return id(Range)
 return hash((self._len, self.start, self[-1]))

 def __iter__(self):
 value = self.start
 if self.step > 0:
 while value < self.stop:
 yield value
 value += self.step
 else:
 while value > self.stop:
 yield value
 value += self.step

 def __len__(self):
 return self._len

 def __repr__(self):
 if self.step == 1:
 return 'Range(, )'.format(self.start, self.stop)
 return 'Range(, , )'.format(self.start, self.stop, self.step)

 def __reversed__(self):
 return iter(self[::-1])

 def _index(self, value):
 index_mul_step = value - self.start
 if index_mul_step % self.step:
 return -1
 index = index_mul_step // self.step
 if 0 <= index < self._len:
 return index
 return -1

 def count(self, value):
 """
 Rangeobject.count(value) -> integer
 Return number of occurrences of value.
 """
 return sum(1 for n in self if n == value)

 def index(self, value, start=0, stop=None):
 """
 Rangeobject.index(value, [start, [stop]]) -> integer
 Return index of value.
 Raise ValueError if the value is not present.
 """
 if start < 0:
 start = max(self._len + start, 0)
 if stop is None:
 stop = self._len
 if stop < 0:
 stop += self._len

 if isinstance(value, numbers.Integral):
 index = self._index(value)
 if start <= index < stop:
 return index
 raise ValueError(' is not in Range'.format(value))

 i = start
 n = self.start + self.step * i
 while i < stop:
 if n == value:
 return i
 i += 1
 n += self.step
 raise ValueError(' is not in Range'.format(value))


collections.abc.Sequence.register(Range)

test_pyrange.py

# pylint: disable = too-few-public-methods

import itertools

from pyrange import Range


class Equal:
 def __eq__(self, other):
 return True


class Indexable:
 def __init__(self, n):
 self.n = n

 def __index__(self):
 return self.n


def test_basic():
 small_builtin_range = range(10)
 small_my_range = Range(10)
 equal = Equal()
 assert small_builtin_range.count(equal) == small_my_range.count(equal) == 10
 assert small_my_range.index(equal) == small_my_range.index(equal) == 0

 big_my_range = Range(0, 10 ** 20, 10 ** 5)
 assert 10 ** 15 in big_my_range
 assert big_my_range[Indexable(10 ** 3)] == 10 ** 8
 assert big_my_range[
 Indexable(10 ** 3):Indexable(10 ** 6):Indexable(10 ** 2)
 ] == Range(10 ** 8, 10 ** 11, 10 ** 7)


def test_slicing():
 for start, stop, step in itertools.product(range(-3, 3), repeat=3):
 if step == 0:
 continue
 builtin_range = range(start, stop, step)
 my_range = Range(start, stop, step)
 for slice_start, slice_stop, slice_step in itertools.product(
 list(range(-3, 3)) + [None], repeat=3
 ):
 if slice_step == 0:
 continue
 slc = slice(slice_start, slice_stop, slice_step)
 builtin_range_slice = builtin_range[slc]
 my_range_slice = my_range[slc]
 for name in ('start', 'stop', 'step'):
 assert (
 getattr(builtin_range_slice, name) ==
 getattr(my_range_slice, name)
 ), (start, stop, step, slice_start, slice_stop, slice_step)


def test_eq_and_hash():
 for start, stop, step in itertools.product(range(-3, 3), repeat=3):
 if step == 0:
 continue
 builtin_range = range(start, stop, step)
 my_range = Range(start, stop, step)
 for start_2, stop_2, step_2 in itertools.product(
 range(-3, 3), repeat=3
 ):
 if step_2 == 0:
 continue
 builtin_range_2 = range(start_2, stop_2, step_2)
 my_range_2 = Range(start_2, stop_2, step_2)
 if builtin_range == builtin_range_2:
 assert my_range == my_range_2, (
 start, stop, step, start_2, stop_2, step_2
 )
 assert hash(my_range) == hash(my_range_2), (
 start, stop, step, start_2, stop_2, step_2
 )

It does not mimic all aspects of range. The range object is immutable:

>>> r = range(1,5,2)
>>> r.start
1
>>> r.start = 3
Traceback (most recent call last):
 module __main__ line 130
 traceback.print_exc()
 module <module> line 1
 r.start = 3
AttributeError: readonly attribute
>>> 

Yours is not. But you might be able to fix that by inheriting from collections.namedtuple.