为什么在（’x’，）中的’x’比’x’=’x’快？

int
PySequence_包含（PyObject*seq，PyObject*ob）
{
使用结果；
PySequenceMethods*sqm=seq-&gt；ob\U类型-&gt；tp\U as\U序列；
if（sqm！=NULL&amp；sqm-&gt；sq_包含！=NULL）
返回（*sqm-&gt；sq_包含）（序号，ob）；
结果=_PySequence_IterSearch（seq，ob，PY_IterSearch_包含）；
返回Py_SAFE_DOWNCAST（结果，Py_ssize_t，int）；
}

请注意，元组定义为

静态PySequenceMethods元组作为序列={
...
（objobjproc）tuplecontains，/*sq_包含*/
};
PyTypeObject PyTuple\u类型={
...
&amp；元组作为序列，/*tp作为序列*/
...
};

那么分支机构呢

如果（sqm！=NULL&amp；sqm-&gt；sq_包含！=NULL）

将采取和*sqm-&gt；sq_contains，这是将采用的函数（objobjproc）tuplecontains

确实如此

静态int
tuplecontains（PyTupleObject*a，PyObject*el）
{
Py_ssize_t i；
int-cmp；
对于（i=0，cmp=0；cmp==0&amp；i&lt；Py_尺寸（a）；+i）
cmp=PyObject\u RichCompareBool（el，PyTuple\u GET\u项（a，i），
Py_-EQ）；
返回cmp；
}

…等等，那不是另一个分支所做的吗？不，那是PyObject\u RichCompare

那条代码路径很短，所以很可能要归结为这两条代码的速度。让我们比较一下

int
PyObject_richcomarebool（PyObject*v，PyObject*w，int op）
{
PyObject*res；
int-ok；
/*对象相同时的快速结果。
保证身份意味着平等*/
如果（v==w）{
if（op==Py_EQ）
返回1；
else if（op==Py_NE）
返回0；
}
...
}

PyObject\u richcomarebool中的代码路径几乎立即终止。对于PyObject\u RichCompare，它会

PyObject*
PyObject_RichCompare（PyObject*v，PyObject*w，int op）
{
PyObject*res；
断言（Py_LT&LT；=op&amp；op&LT；=Py_GE）；
如果（v==NULL | | w==NULL）{…}
如果（Py_EnterRecursiveCall（“比较”））
返回NULL；
res=do_richcompare（v，w，op）；
Py_LeaveRecursiveCall（）；
返回res；
}

前面的路径中没有使用Py\u EnterRecursiveCall/Py\u LeaveRecursiveCall组合，但这些是相对快速的宏，在某些全局变量递增或递减后会短路

do_richcomparedo：

静态PyObject*
do_richcompare（PyObject*v，PyObject*w，int op）
{
richcmpfunc f；
PyObject*res；
int checked_reverse_op=0；
如果（v-&gt；ob_type！=w-&gt；ob_type&amp；…）{…}
if（（f=v-&gt；ob\u type-&gt；tp\u richcompare）！=NULL）{
res=（*f）（v，w，op）；
如果（res！=Py_未实现）
返回res；
...
}
...
}

这将执行一些快速检查以调用v-&gt；ob_类型-&gt；tp_richcompare哪个是

PyTypeObject PyUnicode\u Type={
...
PyUnicode_RichCompare，/*tp_RichCompare*/
...
};

哪一个

PyObject*
PyUnicode_RichCompare（PyObject*左，PyObject*右，整数运算）
{
int结果；
PyObject*v；
如果（！PyUnicode|u Check（左）| |！PyUnicode|u Check（右））
Py_返回未执行；
如果（PyUnicode_就绪（左）=-1||
PyUnicode_就绪（右）=-1）
返回NULL；
如果（左==右）{
开关（op）{
案例Py_EQ：
案例：
案例：
/*字符串等于它本身*/
v=Py_真；
打破
案例：
案例Py_LT：
案例Py\u GT：
v=Py_假；
打破
违约：
...
}
}
如果（…）{…}
否则{…}
Py_增量（v）；
返回v；
}

也就是说，这个快捷键位于left==right。。。但只有这样做之后

如果（！PyUnicode|u Check（左）| |！PyUnicode|u Check（右））
如果（PyUnicode_就绪（左）=-1||
PyUnicode_就绪（右）=-1）

所有路径看起来都是这样的（手动递归内联、展开和修剪已知分支）

POP（）#堆栈内容
TOP（）#
#
案例PyCmp_IN:#运行时派送
#
平方米！=空#发送到内置op
平方米-&gt；sq_包含！=空的#
*平方米-&gt；sq_包含#
#
cmp==0#在循环中进行比较
我&lt；Py_尺寸（a）#
v==w#
op==Py_EQ#
++我#
cmp==0#
#
res&lt；0#转换为Python空间
物件？Py_True:Py_False#
Py_增量（v）#
#
Py_DECREF（左）#堆叠材料
Py_DECREF（右）#
设置顶部（分辨率）#
res==NULL#
调度（）#

vs

POP（）#堆栈内容
TOP（）#
#
默认值：#运行时派送
#
Py_LT&LT；=op#检查操作
op&lt；=佩格#
v==NULL#
w==NULL#
Py_EnterRecursiveCall（…）#递归检查
#
v-&gt；ob_类型！=w-&gt；ob#U类型#更多操作检查
f=v-&gt；ob_类型-&gt；tp#调度至内置op
f！=空的#
#
!PyUnicode_检查（左）#…更多检查
!PYU校验（右））#
PyUnicode_就绪（左）=-1#
PyUnicode_就绪（右）=-1#
左==右#最后，做比较
案例Py_EQ:#立即短路
Py_增量（v）#
#
res！=Py_未实施#
#
Py_LeaveRecursiveCall（）#递归检查
#
Py_DECREF（左）#堆叠材料
Py_DECREF（右）#
设置顶部（分辨率）#
res==NULL#
调度（）#

现在，PyUnicode\u Check和PyUnicode\u READY非常便宜，因为它们只检查两个字段，但是应该很明显，上面的一个是较小的代码路径，它有较少的函数调用，只有一个开关
声明，只是有点瘦

TL；博士：