데이비드 울 레버 (David Wolever)에 대해 언급했듯이, 눈에 보이는 것보다 더 많은 것이 있습니다. 두 가지 방법 모두에 전달 is; 당신은 이것을함으로써 이것을 증명할 수 있습니다
min(Timer("x == x", setup="x = 'a' * 1000000").repeat(10, 10000))
#>>> 0.00045456900261342525
min(Timer("x == y", setup="x = 'a' * 1000000; y = 'a' * 1000000").repeat(10, 10000))
#>>> 0.5256857610074803
첫 번째는 신원으로 확인하기 때문에 너무 빠를 수 있습니다.
하나가 다른 것보다 더 오래 걸리는 이유를 알아 보려면 실행을 추적하십시오.
바이트 코드가 관련 ceval.c되어 COMPARE_OP있기 때문에 둘 다에서 시작합니다.
TARGET(COMPARE_OP) {
PyObject *right = POP();
PyObject *left = TOP();
PyObject *res = cmp_outcome(oparg, left, right);
Py_DECREF(left);
Py_DECREF(right);
SET_TOP(res);
if (res == NULL)
goto error;
PREDICT(POP_JUMP_IF_FALSE);
PREDICT(POP_JUMP_IF_TRUE);
DISPATCH();
}
스택에서 값을 팝합니다 (기술적으로는 하나만 팝)
PyObject *right = POP();
PyObject *left = TOP();
그리고 비교를 실행합니다 :
PyObject *res = cmp_outcome(oparg, left, right);
cmp_outcome 이것입니다 :
static PyObject *
cmp_outcome(int op, PyObject *v, PyObject *w)
{
int res = 0;
switch (op) {
case PyCmp_IS: ...
case PyCmp_IS_NOT: ...
case PyCmp_IN:
res = PySequence_Contains(w, v);
if (res < 0)
return NULL;
break;
case PyCmp_NOT_IN: ...
case PyCmp_EXC_MATCH: ...
default:
return PyObject_RichCompare(v, w, op);
}
v = res ? Py_True : Py_False;
Py_INCREF(v);
return v;
}
이것은 경로가 분할되는 곳입니다. PyCmp_IN분기 않습니다
int
PySequence_Contains(PyObject *seq, PyObject *ob)
{
Py_ssize_t result;
PySequenceMethods *sqm = seq->ob_type->tp_as_sequence;
if (sqm != NULL && sqm->sq_contains != NULL)
return (*sqm->sq_contains)(seq, ob);
result = _PySequence_IterSearch(seq, ob, PY_ITERSEARCH_CONTAINS);
return Py_SAFE_DOWNCAST(result, Py_ssize_t, int);
}
튜플은 다음과 같이 정의됩니다.
static PySequenceMethods tuple_as_sequence = {
...
(objobjproc)tuplecontains, /* sq_contains */
};
PyTypeObject PyTuple_Type = {
...
&tuple_as_sequence, /* tp_as_sequence */
...
};
그래서 지점
if (sqm != NULL && sqm->sq_contains != NULL)
촬영되고 *sqm->sq_contains함수 인 (objobjproc)tuplecontains, 촬영한다.
이것은 않습니다
static int
tuplecontains(PyTupleObject *a, PyObject *el)
{
Py_ssize_t i;
int cmp;
for (i = 0, cmp = 0 ; cmp == 0 && i < Py_SIZE(a); ++i)
cmp = PyObject_RichCompareBool(el, PyTuple_GET_ITEM(a, i),
Py_EQ);
return cmp;
}
... 잠깐, PyObject_RichCompareBool다른 지점에서 취한 것이 아니 었 습니까? 아니, 그이었다 PyObject_RichCompare.
그 코드 경로는 짧았 기 때문에이 두 가지 속도로 떨어질 것입니다. 비교하자.
int
PyObject_RichCompareBool(PyObject *v, PyObject *w, int op)
{
PyObject *res;
int ok;
/* Quick result when objects are the same.
Guarantees that identity implies equality. */
if (v == w) {
if (op == Py_EQ)
return 1;
else if (op == Py_NE)
return 0;
}
...
}
코드 경로는 PyObject_RichCompareBool거의 즉시 종료됩니다. 의 경우 PyObject_RichCompare, 그렇습니다
PyObject *
PyObject_RichCompare(PyObject *v, PyObject *w, int op)
{
PyObject *res;
assert(Py_LT <= op && op <= Py_GE);
if (v == NULL || w == NULL) { ... }
if (Py_EnterRecursiveCall(" in comparison"))
return NULL;
res = do_richcompare(v, w, op);
Py_LeaveRecursiveCall();
return res;
}
Py_EnterRecursiveCall/ Py_LeaveRecursiveCall콤보는 이전 경로에서 촬영되지 않지만, 이들은 상대적으로 빠른 매크로되는거야 증가 및 일부 전역을 감소시키는 후 단락.
do_richcompare 않습니다 :
static PyObject *
do_richcompare(PyObject *v, PyObject *w, int op)
{
richcmpfunc f;
PyObject *res;
int checked_reverse_op = 0;
if (v->ob_type != w->ob_type && ...) { ... }
if ((f = v->ob_type->tp_richcompare) != NULL) {
res = (*f)(v, w, op);
if (res != Py_NotImplemented)
return res;
...
}
...
}
이 호출에 몇 가지 빠른 검사를 수행 v->ob_type->tp_richcompare하다
PyTypeObject PyUnicode_Type = {
...
PyUnicode_RichCompare, /* tp_richcompare */
...
};
어떤
PyObject *
PyUnicode_RichCompare(PyObject *left, PyObject *right, int op)
{
int result;
PyObject *v;
if (!PyUnicode_Check(left) || !PyUnicode_Check(right))
Py_RETURN_NOTIMPLEMENTED;
if (PyUnicode_READY(left) == -1 ||
PyUnicode_READY(right) == -1)
return NULL;
if (left == right) {
switch (op) {
case Py_EQ:
case Py_LE:
case Py_GE:
/* a string is equal to itself */
v = Py_True;
break;
case Py_NE:
case Py_LT:
case Py_GT:
v = Py_False;
break;
default:
...
}
}
else if (...) { ... }
else { ...}
Py_INCREF(v);
return v;
}
즉,이 바로 가기는 left == right...하지만 수행 한 후에 만
if (!PyUnicode_Check(left) || !PyUnicode_Check(right))
if (PyUnicode_READY(left) == -1 ||
PyUnicode_READY(right) == -1)
모든 경로에서 모두 다음과 같이 보입니다 (수동으로 재귀 적으로 알려진 분기를 인라인하고 풀고 정리합니다)
POP() # Stack stuff
TOP() #
#
case PyCmp_IN: # Dispatch on operation
#
sqm != NULL # Dispatch to builtin op
sqm->sq_contains != NULL #
*sqm->sq_contains #
#
cmp == 0 # Do comparison in loop
i < Py_SIZE(a) #
v == w #
op == Py_EQ #
++i #
cmp == 0 #
#
res < 0 # Convert to Python-space
res ? Py_True : Py_False #
Py_INCREF(v) #
#
Py_DECREF(left) # Stack stuff
Py_DECREF(right) #
SET_TOP(res) #
res == NULL #
DISPATCH() #
vs
POP() # Stack stuff
TOP() #
#
default: # Dispatch on operation
#
Py_LT <= op # Checking operation
op <= Py_GE #
v == NULL #
w == NULL #
Py_EnterRecursiveCall(...) # Recursive check
#
v->ob_type != w->ob_type # More operation checks
f = v->ob_type->tp_richcompare # Dispatch to builtin op
f != NULL #
#
!PyUnicode_Check(left) # ...More checks
!PyUnicode_Check(right)) #
PyUnicode_READY(left) == -1 #
PyUnicode_READY(right) == -1 #
left == right # Finally, doing comparison
case Py_EQ: # Immediately short circuit
Py_INCREF(v); #
#
res != Py_NotImplemented #
#
Py_LeaveRecursiveCall() # Recursive check
#
Py_DECREF(left) # Stack stuff
Py_DECREF(right) #
SET_TOP(res) #
res == NULL #
DISPATCH() #
자, PyUnicode_Check그리고 PyUnicode_READY그들은 단지 필드의 몇 가지를 확인 꽤 저렴하지만 상단의 하나가 작은 코드 경로입니다 분명해야한다, 그것은 적은 함수 호출, 하나의 스위치 문이 단지 비트 얇다.
TL; DR :
둘 다 if (left_pointer == right_pointer); 차이점은 그들이 그곳에 가기 위해 얼마나 많은 일을하는지입니다. in그냥 덜합니다.
in대신에 다른 곳에서 사용하지 마십시오==. 가독성에 해를 끼치는 조기 최적화입니다.