1: 链条式比较

通过链式比较，您可以使用多个比较运算符比较多个项目。例如

x > y > z

上面的代码是下面代码的缩写：

x > y and y > z

只有当两个比较结果都为 True 时，计算结果才会为 True

一般形式为

a OP b OP c OP d ...

其中，OP 表示可以使用的多种比较操作之一，字母表示任意有效的表达式。

请注意，0 != 1 != 0 的值为True，尽管 0 != 0 是False。与常见的数学符号不同，x != y != z 表示x、y 和 z 具有不同的值。在大多数情况下，将 == 操作串联起来具有自然的含义，因为相等通常是传递性的。

风格

只要语法正确，使用多少项目和比较操作没有理论限制：

1 > -1 < 2 > 0.5 < 100 != 24

如果每次比较都返回 True，则上述返回值为 True。然而，使用错综复杂的连锁并不是一种好的方式。好的链式应该是 "定向" 的，而不是比

1 > x > -4 > y != 8

副作用

只要有一个比较返回 False，表达式就会立即求值为 False，跳过所有剩余的比较。

请注意，a > exp > b 中的表达式 exp 只会被求值一次，而在 a > exp > b 中，表达式 exp 只会被求值一次。

a > exp and exp > b

如果if a > exp 为真，exp` 将计算两次。

2: 用 is与 ==进行比较

一个常见的误区是混淆了相等比较运算符 is 和 ==。

a == b 比较a和b的值。

a is b 则比较 a 和 b 的相同性。

举例说明

a = 'Python is fun!'
b = 'Python is fun!'
a == b # returns True
a is b # returns False

a = [1, 2, 3, 4, 5]
b = a # b 引用 a
a == b # True
a is b # True

b = a[:] # b 现在引用了 a 的副本
a == b # True
a is b # False [!!]

基本上，可以把它看作是 id(a) == id(b) 的简写。

除此以外，运行时环境的一些怪癖会让事情变得更加复杂。短字符串和小整数在与 is 比较时将返回 True，这是因为 Python 机器试图为相同的对象使用更少的内存。

a = 'short'
b = 'short'
c = 5
d = 5
a is b # True
c is d # True

但较长的字符串和较大的整数将单独存储。

a = 'not so short'
b = 'not so short'
c = 1000
d = 1000
a is b # False
c is d # False

您应该使用 is 来测试 None：

if myvar is not None:
    # not None
    pass
if myvar is None:
    # None
    pass

使用 is 来测试 sentinel（即唯一对象）。

sentinel = object()
def myfunc(var=sentinel):
    if var is sentinel:
        # value wasn’t provided
        pass
    else:
        # value was provided
        pass

3: 大于或小于

x > y
x < y

这些运算符比较两种类型的值，它们是小于运算符和大于运算符。对于数字来说，这只是比较数值的大小：

12 > 4
# True
12 < 4
# False
1 < 4
# True

对于字符串，它们将按词典顺序进行比较，这与字母顺序类似，但又不完全相同。

"alpha" < "beta"
# True
"gamma" > "beta"
# True
"gamma" < "OMEGA"
# False

在这些比较中，小写字母被认为 "大于" 大写字母，这就是为什么 "gamma" < "OMEGA"是 False。如果它们都是大写字母，就会返回预期的按字母顺序排序的结果：

"GAMMA" < "OMEGA"
# True

每种类型对 < 和 > 操作符的计算定义不同，因此在使用前应先了解操作符在特定类型中的含义。

4: 不等于

x != y

如果 x 和 y 不相等，则返回 True，否则返回 False。

12 != 1
# True
12 != '12'
# True
'12' != '12'
# False

5: 等于

x == y

该表达式计算 if x 和 y 是否为相同值，并将结果作为布尔值返回。一般来说，类型和值都需要匹配，因此 int 12 与字符串 '12' 并不相同。

12 == 12
# True
12 == 1
# False
'12' == '12'
# True
'spam' == 'spam'
# True
'spam' == 'spam '
# False
'12' == 12
# False

请注意，每种类型都必须定义一个函数，用于评估两个值是否相同。对于内置类型，这些函数的行为与您所期望的一样，只是根据值是否相同进行评估。不过，自定义类型可以将相等测试定义为任何他们想要的方式，包括总是返回 True 或总是返回 False。

6: 比较对象

为了比较自定义类的相等性，可以通过定义 __eq__ 和 __ne__ 方法来覆盖 == 和 != 。还可以覆盖 __lt__ (<), __le__ (<=), __gt__ (>) 和 __ge__ (>)。请注意，您只需要重载两个比较方法，其余的 Python 都可以处理 (==与 not < 和 not > 相同，等等)。

class Foo(object):
    def __init__(self, item):
      self.my_item = item
    def __eq__(self, other):
      return self.my_item == other.my_item
    
a = Foo(5)
b = Foo(5)
a == b # True
a != b # False
a is b # False

请注意，这种简单的比较假设 other（被比较对象）是相同的对象类型。与其他类型的对象进行比较将导致错误：

class Bar(object):
    def __init__(self, item):
      self.other_item = item
    def __eq__(self, other):
      return self.other_item == other.other_item
    def __ne__(self, other):
      return self.other_item != other.other_item

c = Bar(5)
a == c # throws AttributeError: 'Foo' object has no attribute 'other_item'

如果需要的话，检查 isinstance() 或类似选项将有助于防止出现这种情况。

Tags：le lt