Issue #9213: Add index and count methods to range objects, needed to

meet the API of the collections.Sequence ABC.

Doc/library/stdtypes.rst

@@ -1554,9 +1554,23 @@ looping.  The advantage of the :class:`range` type is that an :class:`range`
 object will always take the same amount of memory, no matter the size of the
 range it represents.  There are no consistent performance advantages.
 
-Range objects have very little behavior: they only support indexing, iteration,
-and the :func:`len` function.
+Range objects have relatively little behavior: they support indexing,
+iteration, the :func:`len` function, and the following methods.
 
+.. method:: range.count(x)
+
+   Return the number of *i*'s for which ``s[i] == x``.  Normally the
+   result will be 0 or 1, but it could be greater if *x* defines an
+   unusual equality function.
+
+    .. versionadded:: 3.2
+
+.. method:: range.index(x)
+
+   Return the smallest *i* such that ``s[i] == x``.  Raises
+   :exc:`ValueError` when *x* is not in the range.
+
+    .. versionadded:: 3.2
 
 .. _typesseq-mutable:
 

Lib/test/test_builtin.py

@@ -1028,6 +1028,60 @@ class BuiltinTest(unittest.TestCase):
         self.assertRaises(TypeError, range, 0.0, 0.0, 1)
         self.assertRaises(TypeError, range, 0.0, 0.0, 1.0)
 
+        self.assertEqual(range(3).count(-1), 0)
+        self.assertEqual(range(3).count(0), 1)
+        self.assertEqual(range(3).count(1), 1)
+        self.assertEqual(range(3).count(2), 1)
+        self.assertEqual(range(3).count(3), 0)
+
+        self.assertEqual(range(10**20).count(1), 1)
+        self.assertEqual(range(10**20).count(10**20), 0)
+        self.assertEqual(range(3).index(1), 1)
+        self.assertEqual(range(1, 2**100, 2).count(2**87), 0)
+        self.assertEqual(range(1, 2**100, 2).count(2**87+1), 1)
+
+        self.assertEqual(range(1, 10, 3).index(4), 1)
+        self.assertEqual(range(1, -10, -3).index(-5), 2)
+
+        self.assertEqual(range(10**20).index(1), 1)
+        self.assertEqual(range(10**20).index(10**20 - 1), 10**20 - 1)
+
+        self.assertRaises(ValueError, range(1, 2**100, 2).index, 2**87)
+        self.assertEqual(range(1, 2**100, 2).index(2**87+1), 2**86)
+
+        class AlwaysEqual(object):
+            def __eq__(self, other):
+                return True
+        always_equal = AlwaysEqual()
+        self.assertEqual(range(10).count(always_equal), 10)
+        self.assertEqual(range(10).index(always_equal), 0)
+
+    def test_range_index(self):
+        u = range(2)
+        self.assertEqual(u.index(0), 0)
+        self.assertEqual(u.index(1), 1)
+        self.assertRaises(ValueError, u.index, 2)
+
+        u = range(-2, 3)
+        self.assertEqual(u.count(0), 1)
+        self.assertEqual(u.index(0), 2)
+        self.assertRaises(TypeError, u.index)
+
+        class BadExc(Exception):
+            pass
+
+        class BadCmp:
+            def __eq__(self, other):
+                if other == 2:
+                    raise BadExc()
+                return False
+
+        a = range(4)
+        self.assertRaises(BadExc, a.index, BadCmp())
+
+        a = range(-2, 3)
+        self.assertEqual(a.index(0), 2)
+
     def test_input(self):
         self.write_testfile()
         fp = open(TESTFN, 'r')

Misc/NEWS

@@ -10,6 +10,10 @@ What's New in Python 3.2 Alpha 3?
 Core and Builtins
 -----------------
 
+- Issue #9212: The range type_items now provides index() and count()
+  methods, to conform to the Sequence ABC.  Patch by Daniel Urban and
+  Daniel Stutzbach.
+
 - Issue #7994: Issue a PendingDeprecationWarning if object.__format__
   is called with a non-empty format string. This is an effort to
   future-proof user code. If a derived class does not currently

Objects/rangeobject.c

@@ -273,9 +273,10 @@ range_reduce(rangeobject *r, PyObject *args)
                          r->start, r->stop, r->step);
 }
 
+/* Assumes (PyLong_CheckExact(ob) || PyBool_Check(ob)) */
 static int
-range_contains(rangeobject *r, PyObject *ob) {
-    if (PyLong_CheckExact(ob) || PyBool_Check(ob)) {
+range_contains_long(rangeobject *r, PyObject *ob)
+{
     int cmp1, cmp2, cmp3;
     PyObject *tmp1 = NULL;
     PyObject *tmp2 = NULL;
@@ -321,12 +322,86 @@ range_contains(rangeobject *r, PyObject *ob) {
     Py_XDECREF(tmp2);
     Py_XDECREF(zero);
     return result;
-    }
-    /* Fall back to iterative search. */
+}
+
+static int
+range_contains(rangeobject *r, PyObject *ob) {
+    if (PyLong_CheckExact(ob) || PyBool_Check(ob))
+        return range_contains_long(r, ob);
+
     return (int)_PySequence_IterSearch((PyObject*)r, ob,
                                        PY_ITERSEARCH_CONTAINS);
 }
 
+static PyObject *
+range_count(rangeobject *r, PyObject *ob)
+{
+    if (PyLong_CheckExact(ob) || PyBool_Check(ob)) {
+        if (range_contains_long(r, ob))
+            Py_RETURN_TRUE;
+        else
+            Py_RETURN_FALSE;
+    } else {
+        Py_ssize_t count;
+        count = _PySequence_IterSearch((PyObject*)r, ob, PY_ITERSEARCH_COUNT);
+        if (count == -1)
+            return NULL;
+        return PyLong_FromSsize_t(count);
+    }
+}
+
+static PyObject *
+range_index(rangeobject *r, PyObject *ob)
+{
+    PyObject *idx, *tmp;
+    int contains;
+    PyObject *format_tuple, *err_string;
+    static PyObject *err_format = NULL;
+
+    if (!PyLong_CheckExact(ob) && !PyBool_Check(ob)) {
+        Py_ssize_t index;
+        index = _PySequence_IterSearch((PyObject*)r, ob, PY_ITERSEARCH_INDEX);
+        if (index == -1)
+            return NULL;
+        return PyLong_FromSsize_t(index);
+    }
+
+    contains = range_contains_long(r, ob);
+    if (contains == -1)
+        return NULL;
+
+    if (!contains)
+        goto value_error;
+
+    tmp = PyNumber_Subtract(ob, r->start);
+    if (tmp == NULL)
+        return NULL;
+
+    /* idx = (ob - r.start) // r.step */
+    idx = PyNumber_FloorDivide(tmp, r->step);
+    Py_DECREF(tmp);
+    return idx;
+
+value_error:
+
+    /* object is not in the range */
+    if (err_format == NULL) {
+        err_format = PyUnicode_FromString("%r is not in range");
+        if (err_format == NULL)
+            return NULL;
+    }
+    format_tuple = PyTuple_Pack(1, ob);
+    if (format_tuple == NULL)
+        return NULL;
+    err_string = PyUnicode_Format(err_format, format_tuple);
+    Py_DECREF(format_tuple);
+    if (err_string == NULL)
+        return NULL;
+    PyErr_SetObject(PyExc_ValueError, err_string);
+    Py_DECREF(err_string);
+    return NULL;
+}
+
 static PySequenceMethods range_as_sequence = {
     (lenfunc)range_length,      /* sq_length */
     0,                  /* sq_concat */
@@ -344,10 +419,18 @@ static PyObject * range_reverse(PyObject *seq);
 PyDoc_STRVAR(reverse_doc,
 "Returns a reverse iterator.");
 
+PyDoc_STRVAR(count_doc,
+"rangeobject.count(value) -> integer -- return number of occurrences of value");
+
+PyDoc_STRVAR(index_doc,
+"rangeobject.index(value, [start, [stop]]) -> integer -- return index of value.\n"
+"Raises ValueError if the value is not present.");
+
 static PyMethodDef range_methods[] = {
-    {"__reversed__",    (PyCFunction)range_reverse, METH_NOARGS,
-        reverse_doc},
+    {"__reversed__",    (PyCFunction)range_reverse, METH_NOARGS, reverse_doc},
     {"__reduce__",      (PyCFunction)range_reduce,  METH_VARARGS},
+    {"count",           (PyCFunction)range_count,   METH_O,      count_doc},
+    {"index",           (PyCFunction)range_index,   METH_O,      index_doc},
     {NULL,              NULL}           /* sentinel */
 };