gh-159092: Optimize comparisons in list operations

Use specialized comparisons for exact int, float and str objects to avoid unnecessary rich-comparison dispatch in list operations.

Author: hetaozdh

Lib/test/test_list.py

@@ -363,6 +363,16 @@ def __eq__(self, other):
         lst = [X(), X()]
         X() in lst
 
+    def test_eq_identity_shortcut(self):
+        # PyObject_RichCompareBool() treats identity as equality, even for
+        # objects that are not equal to themselves (see seq_tests).
+        nan = float("nan")
+        self.assertIn(nan, [nan])
+        self.assertEqual([nan].index(nan), 0)
+        self.assertEqual([nan].count(nan), 1)
+        self.assertEqual([nan], [nan])
+        self.assertNotEqual([nan], [float("nan")])
+
     def test_tier2_invalidates_iterator(self):
         # GH-121012
         for _ in range(100):

Misc/NEWS.d/next/Core_and_Builtins/2026-10-09-17-39-15.gh-issue-159092.qdquS4.rst

@@ -0,0 +1 @@
+Speed up ``x in list``, :meth:`list.index`, :meth:`list.count`, :meth:`list.remove` and equality comparisons for lists of integers, floats and strings by specializing the per-item equality check.

Objects/listobject.c

@@ -16,6 +16,7 @@
 #include "pycore_stackref.h"      // _Py_TryIncrefCompareStackRef()
 #include "pycore_tuple.h"         // _PyTuple_FromArraySteal()
 #include "pycore_typeobject.h"    // _Py_TYPE_VERSION_LIST
+#include "pycore_unicodeobject.h" // _PyUnicode_Equal()
 #include <stddef.h>
 
 /*[clinic input]
@@ -707,17 +708,55 @@ list_length(PyObject *a)
     return PyList_GET_SIZE(a);
 }
 
+static inline PyTypeObject *
+list_fast_eq_type(PyObject *value)
+{
+    if (value != NULL) {
+        PyTypeObject *type = Py_TYPE(value);
+        if (type == &PyLong_Type || type == &PyFloat_Type ||
+            type == &PyUnicode_Type) {
+            return type;
+        }
+    }
+    return NULL;
+}
+
+static inline int
+list_item_eq(PyObject *item, PyObject *value, PyTypeObject *fast_type)
+{
+    if (fast_type != NULL && Py_TYPE(item) == fast_type) {
+        if (item == value) {
+            return 1;
+        }
+        if (fast_type == &PyLong_Type) {
+            PyLongObject *v = (PyLongObject *)item;
+            PyLongObject *w = (PyLongObject *)value;
+            if (_PyLong_BothAreCompact(v, w)) {
+                return _PyLong_CompactValue(v) == _PyLong_CompactValue(w);
+            }
+        }
+        else if (fast_type == &PyFloat_Type) {
+            return PyFloat_AS_DOUBLE(item) == PyFloat_AS_DOUBLE(value);
+        }
+        else {
+            assert(fast_type == &PyUnicode_Type);
+            return _PyUnicode_Equal(item, value);
+        }
+    }
+    return PyObject_RichCompareBool(item, value, Py_EQ);
+}
+
 static int
 list_contains(PyObject *aa, PyObject *el)
 {
-
+    PyTypeObject *fast_type = list_fast_eq_type(el);
     for (Py_ssize_t i = 0; ; i++) {
         PyObject *item = list_get_item_ref((PyListObject *)aa, i);
         if (item == NULL) {
             // out-of-bounds
             return 0;
         }
-        int cmp = PyObject_RichCompareBool(item, el, Py_EQ);
+        int cmp = list_item_eq(item, el, fast_type);
         Py_DECREF(item);
         if (cmp != 0) {
             return cmp;
@@ -3391,13 +3430,14 @@ list_index_impl(PyListObject *self, PyObject *value, Py_ssize_t start,
         if (stop < 0)
             stop = 0;
     }
+    PyTypeObject *fast_type = list_fast_eq_type(value);
     for (Py_ssize_t i = start; i < stop; i++) {
         PyObject *obj = list_get_item_ref(self, i);
         if (obj == NULL) {
             // out-of-bounds
             break;
         }
-        int cmp = PyObject_RichCompareBool(obj, value, Py_EQ);
+        int cmp = list_item_eq(obj, value, fast_type);
         Py_DECREF(obj);
         if (cmp > 0)
             return PyLong_FromSsize_t(i);
@@ -3422,6 +3462,7 @@ list_count_impl(PyListObject *self, PyObject *value)
 /*[clinic end generated code: output=eff66f14aef2df86 input=3bdc3a5e6f749565]*/
 {
     Py_ssize_t count = 0;
+    PyTypeObject *fast_type = list_fast_eq_type(value);
     for (Py_ssize_t i = 0; ; i++) {
         PyObject *obj = list_get_item_ref(self, i);
         if (obj == NULL) {
@@ -3433,7 +3474,7 @@ list_count_impl(PyListObject *self, PyObject *value)
            Py_DECREF(obj);
            continue;
         }
-        int cmp = PyObject_RichCompareBool(obj, value, Py_EQ);
+        int cmp = list_item_eq(obj, value, fast_type);
         Py_DECREF(obj);
         if (cmp > 0)
             count++;
@@ -3460,11 +3501,12 @@ list_remove_impl(PyListObject *self, PyObject *value)
 /*[clinic end generated code: output=b9b76a6633b18778 input=26c813dbb95aa93b]*/
 {
     Py_ssize_t i;
+    PyTypeObject *fast_type = list_fast_eq_type(value);
 
     for (i = 0; i < Py_SIZE(self); i++) {
         PyObject *obj = self->ob_item[i];
         Py_INCREF(obj);
-        int cmp = PyObject_RichCompareBool(obj, value, Py_EQ);
+        int cmp = list_item_eq(obj, value, fast_type);
         Py_DECREF(obj);
         if (cmp > 0) {
             if (list_ass_slice_lock_held(self, i, i+1, NULL) == 0)
@@ -3522,7 +3564,7 @@ list_richcompare_impl(PyObject *v, PyObject *w, int op)
 
         Py_INCREF(vitem);
         Py_INCREF(witem);
-        int k = PyObject_RichCompareBool(vitem, witem, Py_EQ);
+        int k = list_item_eq(vitem, witem, list_fast_eq_type(witem));
         if (k < 0) {
             Py_DECREF(vitem);
             Py_DECREF(witem);