严格比较

Question

在javascript中，有严格的比较运算符op1 === op2和op1 !== op2，它们将比较类型和值。有没有一种 pythonic 的方式来实现同样的事情？

到目前为止，我只能提出以下混乱的条件：

isinstance(op1, type(op2)) and isinstance(op2, type(op1)) and op1 == op2

和

not isinstance(op1, type(op2)) or not isinstance(op2, type(op1)) or op1 != op2

Answer 1

您的方法确实会同时检查值和类型。 Python.

中没有不同的运算符

话虽这么说，但在很多情况下这并不是您想要的 - 在 Python 的哲学中，任何表现得像鸭子的物体都应该被视为鸭子。您通常不仅需要字典，还需要 "mapping-like" 个对象等等 - 只要该对象可用于特定任务，那么代码就应该接受它。

Answer 2

Python 的相等比较器在大多数情况下总是严格的。

例如：

Python

0 == '0'  # False
0 == ''  # False

Javascript

0 == '0'  //True
0 === '0'  //False
0 == ''  //True
0 === '0' //False

Answer 3

Python 的相等比较器是严格的，除了比较 1 和 True，0 和 False 时，1 或 0 的值是 float 类型并不重要，decimal.Decimal, 或长。任何数字类型的零，例如 0、0L、0.0、0j 始终为 False。（请注意，任何其他转换为 bool 的都是 True。请参阅 Truth Value Testing in Python。）除复数 (1L, 1.0, 1) 之外的任何类型的 1 始终为 True。

在Python中：

0 == '0'  # False
0 == '0' and type(0) == type('0')  # False, compare short circuits 
0 == ''  # False
0 == '' and type(0) == type('')  # False, compare short circuits 

1 == True and type(1) == type(True)  # False, makes a difference here
1 == True  # True, also true if 1 was 1.00, etc..
0 == False  # True
False == None  # False
0 == bool(None)  # True

当第一个比较 returns False 时，第二个不被评估，因此它短路，因为 0 和其他任何东西都是 0。虽然这是不必要的，它只适用于比较 1 和 True在第 6 行。

在JavaScript中：

0 == '0'  //true
0 === '0'  //false
0 == ''  //true
0 === '0' //false

1 === true //false
1 == true //true
0 == false //true
false == null //false
0 == !!(null) //true

所以最接近 Python 中的 JavaScript === 的是：

a == b and type(a) == type(b)

但只有在与 1 或 0 进行布尔比较的情况下才需要使用，这不太可能。如果您希望某个值是数字或布尔值，您可能需要修复您的代码。菜鸟的错误是发生这样的事情：

a = 0.0  # a valid value, lets assume it comes from a source that can also return None and we have no control over that.

# Should be:
# if a not None:
if a: # a is cast to bool, bool(0.0) is False
    print "do something here..."

只是为了消除一些混乱，了解 Python 的 is 运算符是件好事。 Python 有一个 is 运算符，如果 is 的两边绑定到同一个对象，则 returns 为真，否则它 returns 错误。使用字符串文字时，对象的生命周期仅适用于语句实例。所以对字符串文字执行 is 是安全的，因为如果它们相同，它们将被分配给同一个对象。这也适用于其他不可变类型，如 bool 和所有数字类型：

0 is '0'  # False
0 is False  # False
0 is 0  # True

这在比较两个变量或一个变量和一个文字时不能保证有效。

当您创建两个空列表时，您会得到两个不同的对象，returns False:

x = []
y = []
x is y  # False

但在这种情况下，这些变量引用同一个列表，并且会继续这样做，直到它们被重新分配，或者从一个到另一个进行深拷贝：

x = y = []
x is y  # True
x.append(1)
x is y  # True
x = [1, ]
x is y  # False, even though the value is same

is 运算符正在比较对象的身份，它正在执行以下操作：

id('0') == id(0)

因此，如果两个对象引用相同的内存，则它们引用相同的对象，因此必须相同。

最好避免是进行严格比较，除非您想检查两个对象是否引用相同的内存。

正如 Simon 的回答所述，Python 的平等哲学与 JavaScript 的不同，确实不需要严格的平等比较。 Python 的相等比较器不像 JavaScript 和 == 那样松散，但同时它与 === 不完全相同。

只要您清楚任何数字类型 (0, 0L, 0.0, 0j) 的零始终等于 False 且任何数字类型的 1 始终等于 False，您就可以使用 Python 的相等比较器除复数 (1, 1L, 1.0) 之外的数字类型为 True。

Answer 4

如果你想超级严格，你也可以使用operator模块。 https://docs.python.org/2/library/operator.html

>>> import operator
>>> operator.eq(True, 1)
True
>>> operator.is_(True, 1)
False

这里的一些答案是错误的。 Python比如，有些类型不会区分，为了一些比较。

例如：

>>> 1 == 1.0
True
>>> operator.eq(1, 1.0)
True
>>> operator.is_(1, 1.0)
False

它比 eq（或 ==）工作得更好，但它依赖于指向相同值的指针的变量，这意味着有很多情况你不喜欢。

如果您想深入了解，以 shorthand 方式实施，如下所示：http://code.activestate.com/recipes/384122/ 将让您 "kind of" 构建自己的运算符。

Answer 5

在python中只有一个严格比较运算符== 假设我们有 2 个案例：

>>> 2 == '2'
False

# Comparison of Int with string, it returns False

>>> 2 == 2.0
True

# Comparison of Int with Float, it returns True

但是在 Julia 等其他编程语言中，比较运算符和严格比较运算符是有区别的。

>>> 2 == 2.0
true

>>> 2 === 2.0
false

# strict comparison operator, namely === which is true only if two values agree fully as to type as well as value.

严格比较

Strict comparison

python

python-3.x