太长，读不下去了范围是一个算术级数，因此它可以非常容易地计算对象是否存在。它甚至可以得到它的索引，如果它真的像列表一样快速。

由于优化，很容易将给定的整数与最小和最大范围进行比较。在Python3中，range（）函数速度如此之快的原因是这里我们对边界使用数学推理，而不是直接迭代range对象。因此，为了解释这里的逻辑：

检查数字是否在开始和停止之间。检查步长精度值是否超过我们的数字。

举个例子，997在范围（4、1000、3）内，因为：4<=997<1000，以及（997-4）%3==0。

其他答案已经很好地解释了这一点，但我想提供另一个实验来说明距离物体的性质：

>>> r = range(5)
>>> for i in r:
        print(i, 2 in r, list(r))
        
0 True [0, 1, 2, 3, 4]
1 True [0, 1, 2, 3, 4]
2 True [0, 1, 2, 3, 4]
3 True [0, 1, 2, 3, 4]
4 True [0, 1, 2, 3, 4]

正如您所看到的，范围对象是一个记住其范围的对象，可以多次使用（即使在对其进行迭代时），而不仅仅是一个一次性生成器。

使用来源，卢克！

在CPython中，range（…）.__contains__（方法包装器）最终将委托给一个简单的计算，该计算检查值是否可能在范围内。这里速度的原因是我们使用的是关于边界的数学推理，而不是距离对象的直接迭代。要解释所使用的逻辑：

检查数字是否介于开始和停止之间，以及检查步幅值是否“超过”我们的数字。

例如，994在范围（41000，2）内，因为：

4<=994<1000，以及(994 - 4) % 2 == 0.

下面包含了完整的C代码，由于内存管理和引用计数的详细信息，它有点冗长，但基本思想是：

static int
range_contains_long(rangeobject *r, PyObject *ob)
{
    int cmp1, cmp2, cmp3;
    PyObject *tmp1 = NULL;
    PyObject *tmp2 = NULL;
    PyObject *zero = NULL;
    int result = -1;

    zero = PyLong_FromLong(0);
    if (zero == NULL) /* MemoryError in int(0) */
        goto end;

    /* Check if the value can possibly be in the range. */

    cmp1 = PyObject_RichCompareBool(r->step, zero, Py_GT);
    if (cmp1 == -1)
        goto end;
    if (cmp1 == 1) { /* positive steps: start <= ob < stop */
        cmp2 = PyObject_RichCompareBool(r->start, ob, Py_LE);
        cmp3 = PyObject_RichCompareBool(ob, r->stop, Py_LT);
    }
    else { /* negative steps: stop < ob <= start */
        cmp2 = PyObject_RichCompareBool(ob, r->start, Py_LE);
        cmp3 = PyObject_RichCompareBool(r->stop, ob, Py_LT);
    }

    if (cmp2 == -1 || cmp3 == -1) /* TypeError */
        goto end;
    if (cmp2 == 0 || cmp3 == 0) { /* ob outside of range */
        result = 0;
        goto end;
    }

    /* Check that the stride does not invalidate ob's membership. */
    tmp1 = PyNumber_Subtract(ob, r->start);
    if (tmp1 == NULL)
        goto end;
    tmp2 = PyNumber_Remainder(tmp1, r->step);
    if (tmp2 == NULL)
        goto end;
    /* result = ((int(ob) - start) % step) == 0 */
    result = PyObject_RichCompareBool(tmp2, zero, Py_EQ);
  end:
    Py_XDECREF(tmp1);
    Py_XDECREF(tmp2);
    Py_XDECREF(zero);
    return result;
}

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);
}

评论行中提到了这个想法的“肉”：

/* positive steps: start <= ob < stop */
/* negative steps: stop < ob <= start */
/* result = ((int(ob) - start) % step) == 0 */ 

最后一点，请查看代码段底部的range_contains函数。如果精确的类型检查失败，那么我们不使用所描述的聪明算法，而是使用_PySequence_IterSearch返回到范围的哑迭代搜索！您可以在解释器中检查此行为（我在这里使用v3.5.0）：

>>> x, r = 1000000000000000, range(1000000000000001)
>>> class MyInt(int):
...     pass
... 
>>> x_ = MyInt(x)
>>> x in r  # calculates immediately :) 
True
>>> x_ in r  # iterates for ages.. :( 
^\Quit (core dumped)

为了补充Martijn的答案，这是源代码的相关部分（在C中，因为范围对象是用本机代码编写的）：

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);
}

因此，对于PyLong对象（在Python 3中为int），它将使用range_contains_long函数来确定结果。该函数本质上检查ob是否在指定范围内（尽管在C中看起来有点复杂）。

如果它不是int对象，则返回到迭代，直到找到值（或没有）。

整个逻辑可以转换为伪Python，如下所示：

def range_contains (rangeObj, obj):
    if isinstance(obj, int):
        return range_contains_long(rangeObj, obj)

    # default logic by iterating
    return any(obj == x for x in rangeObj)

def range_contains_long (r, num):
    if r.step > 0:
        # positive step: r.start <= num < r.stop
        cmp2 = r.start <= num
        cmp3 = num < r.stop
    else:
        # negative step: r.start >= num > r.stop
        cmp2 = num <= r.start
        cmp3 = r.stop < num

    # outside of the range boundaries
    if not cmp2 or not cmp3:
        return False

    # num must be on a valid step inside the boundaries
    return (num - r.start) % r.step == 0

__contains_方法直接与范围的开始和结束进行比较