Python 3 range（）对象不会立即生成数字；它是一个按需生成数字的智能序列对象。它包含的只是开始值、停止值和步长值，然后在迭代对象时，每次迭代都会计算下一个整数。

该对象还实现了该对象__contains_hook，并计算您的数字是否属于其范围。计算是一个（接近）恒定的时间操作*。永远不需要扫描范围内所有可能的整数。

从range（）对象文档中：

与常规列表或元组相比，范围类型的优势在于，范围对象将始终占用相同（少量）的内存，无论其所代表的范围大小（因为它只存储开始、停止和步长值，根据需要计算单个项和子范围）。

因此，range（）对象至少可以做到：

class my_range:
    def __init__(self, start, stop=None, step=1, /):
        if stop is None:
            start, stop = 0, start
        self.start, self.stop, self.step = start, stop, step
        if step < 0:
            lo, hi, step = stop, start, -step
        else:
            lo, hi = start, stop
        self.length = 0 if lo > hi else ((hi - lo - 1) // step) + 1

    def __iter__(self):
        current = self.start
        if self.step < 0:
            while current > self.stop:
                yield current
                current += self.step
        else:
            while current < self.stop:
                yield current
                current += self.step

    def __len__(self):
        return self.length

    def __getitem__(self, i):
        if i < 0:
            i += self.length
        if 0 <= i < self.length:
            return self.start + i * self.step
        raise IndexError('my_range object index out of range')

    def __contains__(self, num):
        if self.step < 0:
            if not (self.stop < num <= self.start):
                return False
        else:
            if not (self.start <= num < self.stop):
                return False
        return (num - self.start) % self.step == 0

这仍然缺少real-range（）支持的一些东西（例如.index（）或.count（）方法、哈希、相等测试或切片），但应该会给你一个想法。

我还简化了__contains__实现，只关注整数测试；如果给一个real-range（）对象一个非整数值（包括int的子类），就会启动一个慢扫描，看看是否匹配，就像对所有包含值的列表使用包含测试一样。这样做是为了继续支持其他恰好支持整数相等测试但不支持整数算术的数字类型。请参阅实现包含测试的Python原始问题。

*接近常数时间，因为Python整数是无限的，所以数学运算也随着N的增长而随时间增长，因此这是一个O（logN）运算。由于它都是在经过优化的C代码中执行的，并且Python将整数值存储在30位块中，因此在您看到由于此处涉及的整数的大小而产生的任何性能影响之前，您可能会耗尽内存。

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

使用来源，卢克！

在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)

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

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

>>> 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）？

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

>>> 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]

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

如果您想知道为什么要将此优化添加到范围中__contains_，以及为什么没有将其添加到xrange中__包含2.7中的_：

首先，正如Ashwini Chaudhary所发现的，1766304期被明确地开放，以优化[x]范围__包含_。这个补丁已经被接受并以3.2的价格签入，但没有被移植到2.7，因为“xrange已经这么长时间了，我看不出它能让我们这么晚才提交补丁。”

同时：

最初，xrange是一个不太序列的对象。正如3.1文档所说：

范围对象的行为很少：它们只支持索引、迭代和len函数。

这并不完全正确；一个xrange对象实际上还支持一些其他的东西，这些东西是通过索引和len自动实现的，包括contains（通过线性搜索）。但当时没有人认为制作完整的序列是值得的。

然后，作为实现抽象基类PEP的一部分，重要的是弄清楚哪些内置类型应该标记为实现哪些ABC，以及xrange/range声称实现集合.Sequence，尽管它仍然只处理相同的“非常少的行为”。直到第9213期，没有人注意到这个问题。针对该问题的补丁不仅将索引和计数添加到了3.2的范围，还重新使用了优化的__contains__（它与索引共享相同的数学，并且直接由计数使用）。**这一更改也适用于3.2，并且没有后移到2.x，因为“这是一个添加新方法的错误修复程序”。（此时，2.7已经超过了rc状态。）

因此，有两次机会将优化后移到2.7，但都被拒绝了。

*事实上，您甚至可以仅通过索引免费获得迭代，但在2.3xrange中，对象有一个自定义迭代器。

**第一个版本实际上重新实现了它，并错误地获得了详细信息，例如，它将在范围（5）==False中为您提供MyIntSubclass（2）。但Daniel Stutzbach的补丁更新版本恢复了以前的大部分代码，包括回退到3.2之前的通用、缓慢的_PySequence_IterSearch__当优化不适用时，contains被隐式使用。

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

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

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

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

but:

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

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

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

TL；博士

range（）返回的对象实际上是一个range对象。此对象实现迭代器接口，因此您可以像生成器、列表或元组一样顺序地迭代其值。

但它也实现了__contains__接口，当对象出现在in运算符的右侧时，实际上会调用该接口。__contains__（）方法返回一个bool，表示in左侧的项是否在对象中。因为范围对象知道它们的边界和步幅，所以这很容易在O（1）中实现。

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

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

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

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

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

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