@@ -15,6 +15,23 @@ PyAPI_FUNC(int) _PyBuffer_ReleaseInInterpreter(
 PyAPI_FUNC(int) _PyBuffer_ReleaseInInterpreterAndRawFree(
         PyInterpreterState *interp, Py_buffer *view);
 
+/* Search the items of the one-dimensional buffer of obj for value, comparing
+   their bytes when that is equivalent to comparing them as objects.
+
+   _PyBuffer_FindItem() returns the index of the first item in [start, stop)
+   equal to value, -1 if there is none, or -2 with an exception set on error.
+   Negative start and stop count from the end, and are clipped like slice
+   bounds.
+
+   _PyBuffer_CountItem() returns the number of items equal to value as an
+   int, or NULL with an exception set on error.
+
+   Implemented in memoryobject.c. */
+PyAPI_FUNC(Py_ssize_t) _PyBuffer_FindItem(
+        PyObject *obj, PyObject *value,
+        Py_ssize_t start, Py_ssize_t stop);
+PyAPI_FUNC(PyObject *) _PyBuffer_CountItem(PyObject *obj, PyObject *value);
+
 #ifdef __cplusplus
 }
 #endif
 
@@ -3,6 +3,7 @@
 """
 
 import unittest
+import struct
 import sys
 import pickle
 from test import support
@@ -442,3 +443,78 @@ def test_pickle(self):
     def test_free_after_iterating(self):
         support.check_free_after_iterating(self, iter, self.type2test)
         support.check_free_after_iterating(self, reversed, self.type2test)
+
+
+class NativeItemsSearchTest:
+    """Tests of count(), index() and "in" for 1-d buffer protocol objects.
+
+    Tests use "needle" for the value being searched for and "haystack" for
+    the object being searched.
+    """
+
+    # All the native single item formats of memoryview.
+    search_formats = ('b', 'B', 'h', 'H', 'i', 'I', 'l', 'L', 'q', 'Q',
+                      'n', 'N', 'P', 'e', 'f', 'd', 'Zf', 'Zd', '?', 'c')
+
+    def make_haystacks(self, fmt, raw):
+        """Make type-specific haystacks interpreting *raw* as *fmt*.
+
+        Subclasses make one haystack per layout under test (for example a
+        contiguous, strided or unaligned memoryview). Yield (name, haystack)
+        pairs, where name identifies the haystack in subtests.
+        """
+        raise NotImplementedError
+
+    def run_search_cases(self, check):
+        """Call check(haystack, haystack_objects, needle) for every needle
+        of every haystack, with a subtest for each haystack.
+
+        haystack_objects is the list of the items of haystack as Python
+        objects, to check results against.
+        """
+        class AlwaysEqual(int):
+            def __eq__(self, other):
+                return True
+            __hash__ = int.__hash__
+
+        nan = float('nan')
+        # Every byte value, then the doubles 0.0, -0.0, NaN and 1.0, all
+        # twice so that values are found more than once.
+        raw = (bytes(range(256)) + struct.pack('4d', 0.0, -0.0, nan, 1)) * 2
+        # Needles which may not be items of the format: of other types, out
+        # of range, or equal to items with different bytes.
+        other_needles = [0, 1, -1, 2**64, 0.0, -0.0, nan, True, False, 1.0,
+                         b'a', AlwaysEqual(5)]
+        for fmt in self.search_formats:
+            for name, haystack in self.make_haystacks(fmt, raw):
+                with self.subTest(fmt=fmt, haystack=name):
+                    haystack_objects = haystack.tolist()
+                    for needle in haystack_objects + other_needles:
+                        check(haystack, haystack_objects, needle)
+
+    def test_search_formats(self):
+        self.run_search_cases(self.check_search)
+
+    def check_search(self, haystack, haystack_objects, needle):
+        """Validate optimized search matches python object search.
+
+        Compares search results between optimized format search and python
+        rich object comparison.
+        """
+        msg = f'needle={needle!r}'
+        n = len(haystack_objects)
+        matches = [i for i, x in enumerate(haystack_objects) if x == needle]
+        self.assertEqual(haystack.count(needle), len(matches), msg)
+        self.assertEqual(needle in haystack, bool(matches), msg)
+        # index() bounds which are negative or past either end are clipped
+        # like slice bounds.
+        bounds = [(0, n), (5, -5), (-3, n), (2, n + 100), (-n - 5, n // 2)]
+        for start, stop in bounds:
+            r = range(n)[start:stop]
+            expected = [i for i in matches if i in r]
+            if expected:
+                self.assertEqual(haystack.index(needle, start, stop),
+                                 expected[0], msg)
+            else:
+                with self.assertRaises(ValueError, msg=msg):
+                    haystack.index(needle, start, stop)
@@ -5,6 +5,7 @@
 import collections.abc
 import unittest
 from test import support
+from test.seq_tests import NativeItemsSearchTest
 from test.support import import_helper, script_helper
 from test.support import os_helper
 from test.support import _2G
@@ -130,6 +131,22 @@ def test_typecodes_documented(self):
                 self.assertGreaterEqual(array.array(typecode).itemsize,
                                         minimum_size)
 
+    def test_search_mutated_during_compare(self):
+        # The buffer is held while searching, so the array cannot be resized
+        # by a comparison.
+        for search in (array.array.index, array.array.count,
+                       array.array.remove, array.array.__contains__):
+            for mutate in (lambda a: a.append(9.0), lambda a: a.clear()):
+                with self.subTest(search=search.__name__):
+                    a = array.array('d', [1.0, 2.0, 3.0])
+                    class Mutate:
+                        def __eq__(self, other):
+                            mutate(a)
+                            return False
+                    self.assertRaises(BufferError, search, a, Mutate())
+                    self.assertEqual(a.tolist(), [1.0, 2.0, 3.0])
+                    a.append(4.0)  # The buffer was released.
+
 
 # Machine format codes.
 #
@@ -167,6 +184,45 @@ def test_typecodes_documented(self):
 
 MACHINE_FORMAT_CODE_MAX = 27
 
+class SearchTest(NativeItemsSearchTest, unittest.TestCase):
+    # 'w' is tested by test_search_unicode. The raw is not valid UCS4 so
+    # conversion to a list fails.
+    search_formats = tuple(fmt for fmt in array.typecodes if fmt != 'w')
+
+    def make_haystacks(self, typecode, raw):
+        yield 'array', array.array(typecode, raw)
+
+    def test_search_remove(self):
+        self.run_search_cases(self.check_remove)
+
+    def check_remove(self, a, haystack_objects, needle):
+        """Check a.remove(needle) against removing the first item of
+        haystack_objects equal to needle."""
+        matches = [i for i, x in enumerate(haystack_objects) if x == needle]
+        b = array.array(a.typecode, a)
+        if matches:
+            b.remove(needle)
+            after = array.array(a.typecode, a)
+            del after[matches[0]]
+            self.assertEqual(b.tobytes(), after.tobytes(), repr(needle))
+        else:
+            with self.assertRaises(ValueError, msg=repr(needle)):
+                b.remove(needle)
+
+    def test_search_unicode(self):
+        a = array.array('w', 'abc\U0010ffff\0ab' * 2)
+        haystack_objects = a.tolist()
+        for needle in ['a', 'b', '\U0010ffff', '\0', 'z', 'ab', '', b'a', 97]:
+            self.check_search(a, haystack_objects, needle)
+            self.check_remove(a, haystack_objects, needle)
+        # memoryview does not support 'w' items, but can search them.
+        m = memoryview(a)
+        self.assertEqual(m.count('a'), a.count('a'))
+        self.assertEqual(m.index('\0', 1), a.index('\0', 1))
+        self.assertIn('\U0010ffff', m)
+        self.assertNotIn('z', m)
+        self.assertRaises(NotImplementedError, m.__getitem__, 0)
+
 
 class ArrayReconstructorTest(unittest.TestCase):
 
 
@@ -2963,6 +2963,16 @@ def assert_out_of_bounds_error(self, dim):
         self.assertEqual(str(cm.exception),
                          "index out of bounds on dimension %d" % (dim,))
 
+    def test_memoryview_search_unsupported_format(self):
+        nd = ndarray([1, 2], shape=[2], format='<i')
+        m = memoryview(nd)
+        # Ensure empty and non-empty behave the same.
+        for mv in m, m[:0]:
+            self.assertRaises(NotImplementedError, mv.count, 1)
+            self.assertRaises(NotImplementedError, mv.index, 1)
+            self.assertRaises(NotImplementedError, lambda: 1 in mv)
+        self.assertRaises(NotImplementedError, m.index, 1, 2)
+
     def test_memoryview_index(self):
 
         # ndim = 0
@@ -4631,6 +4641,17 @@ def __release_buffer__(self, buffer):
             self.assertEqual(mv.tobytes(), b"hello")
         self.assertFalse(wr.held)
 
+    def test_search_restricted_memoryview(self):
+        # The memoryview passed to __release_buffer__() refuses to export new
+        # views, but can still be searched.
+        results = []
+        class Searcher(bytearray):
+            def __release_buffer__(self, mv):
+                results.append((97 in mv, mv.count(98), mv.index(99)))
+
+        memoryview(Searcher(b"abc")).release()
+        self.assertEqual(results, [(True, 1, 2)])
+
     def test_buffer_flags(self):
         class PossiblyMutable:
             def __init__(self, data, mutable) -> None:
 
@@ -17,6 +17,7 @@
 
 from itertools import product
 from test import support
+from test.seq_tests import NativeItemsSearchTest
 from test.support import import_helper, threading_helper
 
 
@@ -949,6 +950,26 @@ def test_overflows_in_floats(self):
             complex_view[0] = 1e300j
         self.assertEqual(complex_view[0], 123+321j)
 
+    def test_search_released_during_compare(self):
+        # The buffer is held while searching, so a comparison cannot release
+        # the memoryview. Leaving the with block fails if it is still held.
+        for name in 'index', 'count', '__contains__':
+            with memoryview(array.array('d', [1.0, 2.0, 3.0])) as m:
+                class Release:
+                    def __eq__(self, other):
+                        m.release()
+                        return False
+                with self.assertRaises(BufferError, msg=name):
+                    getattr(m, name)(Release())
+
+
+class SearchTest(NativeItemsSearchTest, unittest.TestCase):
+    def make_haystacks(self, fmt, raw):
+        mv = memoryview(raw).cast(fmt)
+        yield 'contiguous', mv
+        yield 'strided', mv[::3]
+        yield 'unaligned', memoryview(b'\0' + raw)[1:].cast(fmt)
+
 
 @threading_helper.requires_working_threading()
 @support.requires_resource("cpu")
 
@@ -0,0 +1,6 @@
+Speed up ``in``, :meth:`memoryview.count` and :meth:`memoryview.index` for
+:class:`memoryview` objects with integer formats. Attempts to resize during
+these operations may now raise :exc:`BufferError`. Searching is 60-130x faster
+for 100,000 items. :meth:`memoryview.index` now raises
+:exc:`NotImplementedError` for an unsupported format even when there are no
+items to search, like :meth:`~memoryview.count` and ``in``.
@@ -0,0 +1,4 @@
+Speed up ``in``, :meth:`array.array.count`, :meth:`array.array.index` and
+:meth:`array.array.remove` for :class:`array.array` objects with integer
+typecodes. Attempts to resize during these operations may now raise
+:exc:`BufferError`. Searching is 120-350x faster for 100,000 items.