Python子串搜索性能深度解析：in、find与index的效率对比

小林子

发布时间：2026-10-14 | 3人浏览过

原创

本文深入对比Python中in、find、index及__contains__四种子串查找方式的性能。测试表明in运算符速度最快，因其直接调用C层函数而避免虚拟机开销；find与index核心逻辑一致，但index在查找失败时抛出异常的机制导致其性能略低。文章从CPython源码层面解析了操作符与属性调用的底层差异，建议在实际开发中优先使用in运算符以获得最佳可读性与执行效率。

Python子串搜索性能对比

起步

在Python中处理子串搜索时，开发者通常面临多种选择，包括使用in运算符、find方法、index方法以及__contains__魔术方法。为了明确各方法的性能差异，我们对这几种实现方式进行了基准测试。


import timeit

def in_(s, other):
  return other in s

def contains(s, other):
  return s.__contains__(other)

def find(s, other):
  return s.find(other) != -1

def index(s, other):
  try:
    s.index(other)
  except ValueError:
    return False
  return True

perf_dict = {
  'in:True': min(timeit.repeat(lambda: in_('superstring', 'str'))),
  'in:False': min(timeit.repeat(lambda: in_('superstring', 'not'))),
  '__contains__:True': min(timeit.repeat(lambda: contains('superstring', 'str'))),
  '__contains__:False': min(timeit.repeat(lambda: contains('superstring', 'not'))),
  'find:True': min(timeit.repeat(lambda: find('superstring', 'str'))),
  'find:False': min(timeit.repeat(lambda: find('superstring', 'not'))),
  'index:True': min(timeit.repeat(lambda: index('superstring', 'str'))),
  'index:False': min(timeit.repeat(lambda: index('superstring', 'not'))),
}

print(perf_dict)

测试结果显示：

{ 'in:True': 0.2763608000000001, 'in:False': 0.2794432, '__contains__:True': 0.40546490000000013, '__contains__:False': 0.4122471000000001, 'find:True': 0.497128, 'find:False': 0.4951530000000002, 'index:True': 0.5243821999999998, 'index:False': 0.8693923999999988 }

从上述数据可以直观看出，使用in运算符进行子串搜索的性能表现最优。

了解现象背后的原理同样重要，接下来我们将深入分析导致这些性能差异的根本原因。

in与contains的性能差异分析

in 与 __contains__ 比较

熟悉Python协议机制的开发者知道，in运算符在底层实际上是调用了对象的__contains__方法。然而，测试数据显示in的执行速度明显快于直接调用__contains__，尽管两者最终都指向相同的C语言函数。

在CPython的实现中，in被设计为操作符，它直接映射到序列类型（sq_contains）中的C级函数指针。对于字符串类型（str），其sq_contains直接指向最终的C层处理函数。相比之下，调用__contains__方法需要先通过LOAD_ATTR在字符串属性中进行查找，随后还需要为CALL_FUNCTION创建必要的函数调用栈空间。

这意味着，in运算符直接指向最终的C层函数，实现了一步到位的高效调用，且避开了Python虚拟机的函数调用开销。而__contains__的调用方式则包含了属性查找和Python函数调用的额外开销，因此str.__contains__(other)的形式执行速度要慢得多。

通常情况下，in方式更快仅适用于Python内置的C实现类。对于用户自定义类，由于最终执行的都是Python级别的代码，因此无论使用in还是__contains__，都需要承担函数调用所需的栈空间开销。

find与index的行为与性能区别

find 与 index 的比较

find和index在查找逻辑上的唯一区别在于：当子串不存在时，index会抛出ValueError异常。从源码层面来看：


static PyObject *
unicode_find(PyObject *self, PyObject *args)
{
  /* initialize variables to prevent gcc warning */
  PyObject *substring = NULL;
  Py_ssize_t start = 0;
  Py_ssize_t end = 0;
  Py_ssize_t result;

  if (!parse_args_finds_unicode("find", args, &substring, &start, &end))
    return NULL;

  if (PyUnicode_READY(self) == -1)
    return NULL;

  result = any_find_slice(self, substring, start, end, 1);

  if (result == -2)
    return NULL;

  return PyLong_FromSsize_t(result);
}

static PyObject *
unicode_index(PyObject *self, PyObject *args)
{
  /* initialize variables to prevent gcc warning */
  Py_ssize_t result;
  PyObject *substring = NULL;
  Py_ssize_t start = 0;
  Py_ssize_t end = 0;

  if (!parse_args_finds_unicode("index", args, &substring, &start, &end))
    return NULL;

  if (PyUnicode_READY(self) == -1)
    return NULL;

  result = any_find_slice(self, substring, start, end, 1);

  if (result == -2)
    return NULL;

  if (result < 0) {
    PyErr_SetString(PyExc_ValueError, "substring not found");
    return NULL;
  }

  return PyLong_FromSsize_t(result);
}

两者的实现逻辑基本一致，因此在子串存在的情况下，它们的性能表现相同。然而，当子串不存在时，index方法需要执行异常设置操作，这涉及异常栈空间分配等异常处理机制，从而导致了额外的性能损耗，使其速度略慢于find。