if a == b or a == c: vs if a in {b, c}:

Question

在我的代码中，我曾经相当频繁地进行if a == b or a == c or a == d: 之类的比较。在某些时候，我发现如果这些值不可散列，这些可以很容易地缩短为if a in {b, c, d}: 或if a in (b, c, d):。但是，我从未在其他任何人的代码中看到过这样的构造。这可能是因为：

1. == 方式比较慢。
2. == 方式更符合 Python 风格。
3. 他们实际上做了微妙的不同的事情。
4. 我碰巧没有看过任何需要的代码。
5. 我看过它，只是忽略或忘记了它。
6. 不需要进行这样的比较，因为其他地方的代码会更好。
7. 除了我，没有人想到过in。

如果有的话，是什么原因？

Answer 1

对于简单值（即不是表达式或NaNs），if a == b or a == c 和 if a in <iterable of b and c> 是等价的。

如果值是可散列的，最好使用带有 set literal 的 in 而不是元组或列表文字：

if a in {b, c}: ...

CPython 的 peephole optimiser 通常能够将其替换为缓存的 frozenset() 对象，并且针对集合的成员资格测试是 O(1) 操作。

Answer 2

性能方面：“in”更好

timeit.timeit("pub='1'; pub == 1 or pub == '1'")
0.07568907737731934
timeit.timeit("pub='1'; pub in[1, '1']")
0.04272890090942383
timeit.timeit("pub=1; pub == 1 or pub == '1'")
0.07502007484436035
timeit.timeit("pub=1; pub in[1, '1']")
0.07035684585571289

“in”还确保代码不重复 a == 1 或 a == 2 是重复的。 而且不好读。 “in”只是让它更容易理解。这是简单而优雅的代码实践的案例之一。简而言之，如果我们还没有使用“in”，我们（应该）更频繁地使用它。

Answer 3

我很想知道直接比较与检查数组之间的时间差异是什么。

结论：构建数组的成本不是免费的，在考虑速度差异时必须考虑到。

如果在比较时正在构建数组，则从技术上讲它比简单比较慢。因此，简单的比较在循环内或循环外会更快。

也就是说，如果数组已经构建好了，那么在大循环中检查数组会比进行简单的比较更快。

$ speed.py
inarray                   x 1000000:  0.277590343844
comparison                x 1000000:  0.347808290754
makearray                 x 1000000:  0.408771123295

import timeit

NUM = 1000000

a = 1
b = 2
c = 3
d = 1

array = {b,c,d}
tup = (b,c,d)
lst = [b,c,d]

def comparison():
    if a == b or a == c or a == d:
        pass

def makearray():
    if a in {b, c, d}:
        pass

def inarray():
    if a in array:
        pass

def maketuple():
    if a in (b,c,d):
        pass

def intuple():
    if a in tup:
        pass

def makelist():
    if a in [b,c,d]:
        pass

def inlist():
    if a in lst:
        pass


def time_all(funcs, params=None):
    timers = []
    for func in funcs:
        if params:
            tx = timeit.Timer(lambda: func(*params))
        else:
            tx = timeit.Timer(lambda: func())
        timers.append([func, tx.timeit(NUM)])

    for func, speed in sorted(timers, key=lambda x: x[1]):
        print "{fn:<25} x {n}: ".format(fn=func.func_name, n=NUM), speed
    print ""
    return

time_all([comparison,
          makearray,
          inarray,
          intuple,
          maketuple,
          inlist,
          makelist
          ], 
         )

这并不能完全回答您关于您不经常看到使用 in 进行比较的原因的问题。我会推测，但它可能是 1、2、4 的混合，以及作者需要的情况编写特定的代码。

我个人根据情况使用了这两种方法。选择通常归结为速度或简单性。

---

编辑：

@bracco23 是对的，使用元组 vs 数组 vs 列表会改变时间。

$ speed.py
inarray                   x 1000000:  0.260784980761
intuple                   x 1000000:  0.288696420718
inlist                    x 1000000:  0.311479982167
maketuple                 x 1000000:  0.356532747578
comparison                x 1000000:  0.360010093964
makearray                 x 1000000:  0.41094386108
makelist                  x 1000000:  0.433603059099