这一切都是关于一种懒惰的评估方法和一些额外的范围优化。在实际使用之前，不需要计算范围内的值，或者由于额外的优化，甚至不需要进一步计算。

顺便说一下，您的整数没有那么大，请考虑sys.maxsize

范围内的sys.maxsize（sys.maxssize）非常快

由于优化，很容易将给定的整数与范围的最小值和最大值进行比较。

but:

范围（sys.maxsize）中的十进制（sys.mazsize）非常慢。

（在这种情况下，范围内没有优化，所以如果python收到意外的Decimal，python将比较所有数字）

您应该了解实现细节，但不应依赖它，因为这可能会在将来发生变化。

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

为了补充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

对于较大的x值，请尝试x-1 in（i代表i in range（x）），这使用生成器理解来避免调用范围__包含优化。

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

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

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

这里的根本误解是认为射程是一个发生器。事实并非如此。事实上，它不是任何类型的迭代器。

你可以很容易地看出这一点：

>>> a = range(5)
>>> print(list(a))
[0, 1, 2, 3, 4]
>>> print(list(a))
[0, 1, 2, 3, 4]

如果它是一个生成器，迭代一次就会耗尽它：

>>> b = my_crappy_range(5)
>>> print(list(b))
[0, 1, 2, 3, 4]
>>> print(list(b))
[]

实际的范围是一个序列，就像一个列表。你甚至可以测试一下：

>>> import collections.abc
>>> isinstance(a, collections.abc.Sequence)
True

这意味着它必须遵循作为一个序列的所有规则：

>>> a[3]         # indexable
3
>>> len(a)       # sized
5
>>> 3 in a       # membership
True
>>> reversed(a)  # reversible
<range_iterator at 0x101cd2360>
>>> a.index(3)   # implements 'index'
3
>>> a.count(3)   # implements 'count'
1

范围和列表的区别在于，范围是一个惰性或动态序列；它不记得所有的值，只记得开始、停止和步骤，并根据需要在getitem上创建值。

（顺便说一句，如果您打印（iter（a）），您会注意到range使用与list相同的listiterator类型。这是如何工作的？listiterator除了提供了__getitem_的C实现之外，并没有使用任何关于list的特殊功能，所以它也适用于range。）

现在，没有什么能说明序列__事实上，contains必须是常数时间，对于像list这样的序列的明显例子，它不是。但没有什么能说明这是不可能的。而且实现射程更容易__包含只是在数学上检查它（（val-start）%step，但处理负步骤有一些额外的复杂性），而不是实际生成和测试所有值，所以为什么它不应该以更好的方式进行呢？

但语言中似乎没有任何东西能保证这一点。正如Ashwini Chaudhari所指出的，如果你给它一个非整数值，而不是转换成整数并进行数学测试，那么它将返回到迭代所有值并逐一比较。正因为CPython 3.2+和PyPy 3.x版本恰好包含这种优化，而且这是一个明显的好主意，而且很容易做到，所以IronPython或NewKickAssPython 3.x没有理由不考虑它。（事实上，CPython 3.0-3.1没有包含它。）

如果range实际上是一个生成器，比如my_crappy_range，那么这样测试__contains__是没有意义的，或者至少它的意义不会很明显。如果您已经迭代了前3个值，那么1是否仍在生成器中？对1的测试是否会导致它迭代并消耗所有值，直到1（或直到第一个值>=1）？