为什么要“ a == x或y或z”总是评估为真？我如何比较“ a”所有这些？

Question

我正在编写一个安全系统，该系统拒绝访问未经授权的用户。

name = input("Hello. Please enter your name: ")
if name == "Kevin" or "Jon" or "Inbar":
    print("Access granted.")
else:
    print("Access denied.")

它可以按预期授予授权用户的访问权限，但也允许未经授权的用户访问！

Hello. Please enter your name: Bob
Access granted.

为什么会发生这种情况？我很清楚地说，仅当名称等于Kevin，Jon或Inbar时才授予访问权限。我还尝试了相反的逻辑，如果“ kevin”或“ jon”或“ inbar” ==名称，但结果是相同的。

---

_{这个问题旨在作为这个非常常见问题的规范重复目标。还有另一个流行的问题如何测试多个变量的平等变量以抗A单个值？存在相同的基本问题，但是比较目标是逆转的。这个问题不应作为该问题的重复，因为新移民遇到了这个问题，而Python可能会在}

而不是==，这里有解决方案：如何测试列表中多个值的成员

Answer 1

方法

是数据科学家如何处理此问题的

最简单方法是消除比较操作员的需求并使用列表。这在安全系统上看起来令人印象深刻，因为您学会访问ORMS。

user = input("Enter name: ")

if user in {"Bob", "Kevin", "Joe"}:
   print("Access granted, " + str(user) + ".")
else:
   print("Access denied.")

或者，您可以类似于上面的 extike 相同的代码，只需将注册用户的列表放入其自己的列表中：

user = input("Enter name: ")
users = {"Bob", "Kevin", "Joe", "a million more users if you like"}

if user in users:
   print("Access granted, " + str(user) + ".")
else:
   print("Access denied.")

如果您想安全地完成此协议而没有攻击风险，请设置双参数。这将检查您的迷你摩托<代码>第一个和最后名称字段，以及password或秘密问题钥匙。如果您想有效地懒惰的用户凭据而无需哈希：

def lazy(i):
   j = 0 # For example
   while j < i:
      yield j
      j += 1

循环将消耗 ，可以节省系统和能量，

则 可以将对象排序。迭代列表：

for j in lazy_range(10):
   do_something_here(j)

可以从任何角度解决此问题：内存管理，安全性，或者仅通过有机列表或包装ORM解决。

Answer 2

在许多情况下，Python的外观和行为就像天然英语一样，但这是该抽象失败的一种情况。人们可以使用上下文线索来确定“ Jon”和“ Inbar”是动词“等于”的对象，但是Python的解释器更为字面意义。

if name == "Kevin" or "Jon" or "Inbar":

在逻辑上等同于：

if (name == "Kevin") or ("Jon") or ("Inbar"):

对于用户bob而言，它等效于：

if (False) or ("Jon") or ("Inbar"):

或 operator 选择第一个操作系统那就是“ truthy” ，即如果条件（或最后一个，如果没有一个是“真实的”）

if "Jon":

：乔恩是真实的，如果块执行。这就是导致“授予”打印的“访问权限”的原因。

所有这些推理也适用于“ kevin”或“ jon”或“ inbar” ==名称的表达式。第一个值<代码>“ kevin”是正确的，因此 block execute 。

---

有三种通用方法可以正确构建此条件。

1. 使用多个==操作员明确检查每个值：

    如果名称==“ kevin”或name ==“ jon”或name ==“ inbar”：
    

2. 构成有效值的集合（集合，列表或元组），并在操作员测试会员资格：

    如果在{“ Kevin”，“ Jon”，“ Inbar”}中名称：
    

3. 使用生成器表达式在循环中明确检查针对每个值：

    如果任何（name == auth for auth for auth [“ kevin”，“ jon”，“ inbar”]）：）：
    

一般而言第二应该是首选，因为它更容易阅读和更快：

>>> import timeit
>>> timeit.timeit('name == "Kevin" or name == "Jon" or name == "Inbar"',
    setup="name='Inbar'")
0.0960568820592016
>>> timeit.timeit('name in {"Kevin", "Jon", "Inbar"}', setup="name='Inbar'")
0.034957461059093475
>>> timeit.timeit('any(name == auth for auth in ["Kevin", "Jon", "Inbar"])',
    setup="name='Inbar'")
0.6511583919636905

---

对于那些可能想要证明的人，如果a == b或c或d或e：...确实是这样解析的。内置ast模块提供了答案：

>>> import ast
>>> ast.parse("a == b or c or d or e", "<string>", "eval")
<ast.Expression object at 0x7f929c898220>
>>> print(ast.dump(_, indent=4))
Expression(
    body=BoolOp(
        op=Or(),
        values=[
            Compare(
                left=Name(id='a', ctx=Load()),
                ops=[
                    Eq()],
                comparators=[
                    Name(id='b', ctx=Load())]),
            Name(id='c', ctx=Load()),
            Name(id='d', ctx=Load()),
            Name(id='e', ctx=Load())]))

正如人们所看到的，是布尔操作员或应用于四个子表达式：比较a == b a == b < /代码>;和简单的表达式c，d和e。

Answer 3

总结所有现有答案

（并添加了一些我的观点）

说明：

if name == "Kevin" or "Jon" or "Inbar":

逻辑上等同于：

if (name == "Kevin") or ("Jon") or ("Inbar"):

对于用户bob而言，它等同于：

if (False) or ("Jon") or ("Inbar"):

注意：python评估任何非零整数的逻辑值为> true。因此，所有非空列表，集合，字符串等都是可评估的，并返回true

或操作员选择具有正面真实价值的第一个参数。

因此，“乔恩”具有正面的真实价值，而IF块执行，因为它现在等同于

if (False) or (True) or (True):

导致“访问授予”的内容，而不论其名称输入如何。

解决方案：

解决方案1：使用多个==操作员明确检查每个值

if name == "Kevin" or name == "Jon" or name == "Inbar":
    print("Access granted.")
else:
    print("Access denied.")

解决方案2：构成有效值的集合（一组，例如，列表或元组），并在中使用运算符中的测试成员资格（更快，首选方法）

if name in {"Kevin", "Jon", "Inbar"}:
    print("Access granted.")
else:
    print("Access denied.")

或

if name in ["Kevin", "Jon", "Inbar"]:
    print("Access granted.")
else:
    print("Access denied.")

解决方案3：使用基本（并且不是很高效） if-elif-else结构

if name == "Kevin":
    print("Access granted.")
elif name == "Jon":
    print("Access granted.")
elif name == "Inbar":
    print("Access granted.")
else:
    print("Access denied.")

Answer 4

中有3个条件检查如果名称==“ kevin”或“ jon”或“ inbar”：

• name ==“ kevin”
• “ jon”
• “ inbar”

，此if语句等同于

if name == "Kevin":
    print("Access granted.")
elif "Jon":
    print("Access granted.")
elif "Inbar":
    print("Access granted.")
else:
    print("Access denied.")

自<<代码> elif“ jon” 将始终是正确的，因此可以访问任何用户的

解决方案，

---

下使用任何一种方法

您可以在 fast> fast

if name in ["Kevin", "Jon", "Inbar"]:
    print("Access granted.")
else:
    print("Access denied.")

slow> slow

if name == "Kevin" or name == "Jon" or name == "Inbar":
    print("Access granted.")
else:
    print("Access denied.")

slow + slow + 不必要的代码

if name == "Kevin":
    print("Access granted.")
elif name == "Jon":
    print("Access granted.")
elif name == "Inbar":
    print("Access granted.")
else:
    print("Access denied.")

Answer 5

可以评估不超空列表，集合，字符串等，因此返回true。

因此，当您说：

a = "Raul"
if a == "Kevin" or "John" or "Inbar":
    pass

您实际上是在说：

if "Raul" == "Kevin" or "John" != "" or "Inbar" != "":
    pass

由于“ John”和“ Inbar”中的至少一个不是一个空字符串，因此整个表达式总是返回的！

解决方案：

a = "Raul"
if a == "Kevin" or a == "John" or a == "Inbar":
    pass

或：

a = "Raul"
if a in {"Kevin", "John", "Inbar"}:
    pass

Answer 6

使用匹配/案例在Python 3.10及以上

python 3.10 在语言中添加了一个新的语法。它被正式描述为“结构模式匹配”，但大多数人根据语法称其为：“ 匹配/case”。

• ”
• 动机和基本原理（即，添加了原因，以及启发了设计的原因）
• 官方教程

我们可以通过制作一个与所有接受的用户名匹配的“案例”，并使用“通配符” case_ 代替else。因此：

name = input("Hello. Please enter your name: ")
match name:
    case "Kevin" | "Jon" | "Inbar":
        print("Access granted.")
    case _:
        print("Access denied.")

请注意，使用|而不是或“组合”案例。这是一种特殊的语法：python 尝试计算“ kevin” | “乔恩” | “ inbar” first（|与字符串无效），而是解释整个行的不同，因为它以case 。

Answer 7

简单的工程问题，让我们简单地进一步。

In [1]: a,b,c,d=1,2,3,4
In [2]: a==b
Out[2]: False

但是，从语言C继承，Python评估非零整数的逻辑值为真实。

In [11]: if 3:
    ...:     print ("yey")
    ...:
yey

现在，Python建立在该逻辑上，让您使用逻辑文字，例如或在整数上，因此

In [9]: False or 3
Out[9]: 3

最终

In [4]: a==b or c or d
Out[4]: 3

编写的正确方法是：

In [13]: if a in (b,c,d):
    ...:     print('Access granted')

为了安全起见，我还建议您不要硬代码密码。

Answer 8

除了其他一些相当稀有的 Walrus操作员的有用案例已经提到了。这也往往也是一个有用的情况。

def calc_value():
    return 43

if (v := calc_value()) == 43 and v > 42:
    print('happy short, efficient and readable code')

之所以起作用，是因为 如果说明<-Statement < /code>单独读取。因此（v：= calc_value（））被执行，并将值分配给v，如果第一次失败，则在不同条件或计算的名称空间中仍然具有v 。