关于运算符：Python !=运算符和 is not


Python != operation vs “is not”

在对这个问题的评论中，我看到一个建议使用

1
result is not None

VS

1
result != None

我想知道有什么区别，为什么一个会比另一个被推荐？

相关讨论

这是一个平等的测试。当右手和左手两侧均等时(根据他们的__eq__或__cmp__方法)

这是一个身份测试。当右手侧和左手侧是同一个目标时，检查是一样的。没有方法，物体无法影响is操作。

你用is(和is not)来唱歌，如None你不在乎那些可能想要伪装成None的对象，或当对比None时你想保护对象免遭破坏的地方。

相关讨论

首先，让我谈一谈。如果你只想回答你的问题，请回答你的问题。

定义

对象身份：当你创建一个对象时，你可以将它指定为一个变量。然后你可以将它分配给另一个变量。另一个

1
2
3
4
5
6
>>> button = Button()
>>> cancel = button
>>> close = button
>>> dismiss = button
>>> print(cancel is close)
True

在这一情况下，所有参照记忆中相同的对象。你只创建了一个对象，所有三个变量都参照这个对象。我们说，所有提到的相同对象都是单一对象。

Object equality:when you compare two objects，you usually don't care that it refers to the exactly same objects in memory.以对象均衡为基础，您可以为两个对象的比较制定自己的规则。当你写作的时候，你最重要的是说所以你可以使用自己的比较逻辑。

平等比较理论

理性：两个物体的确切数据相同，但并非相同。(They are not the same object in memory.)Example：Strings

1
2
3
4
5
6
7
>>> greeting ="It's a beautiful day in the neighbourhood."
>>> a = unicode(greeting)
>>> b = unicode(greeting)
>>> a is b
False
>>> a == b
True

注：我在这里使用独码弦乐，因为Python很聪明，足以在记忆中不创造新的人的情况下恢复正常弦乐。

在这里，我有两条单一的弦乐线，一条单一的弦乐线，另一条单一的弦乐线。他们的确切内容相同，但他们在记忆中不是同样的对象。然而，当我们比较它们时，我们想要它们与平等的比较。这里发生的是，单一代码对象实现了__eq__方法。

1
2
3
4
5
6
7
8
9
10
11
12
class unicode(object):
    # ...

    def __eq__(self, other):
        if len(self) != len(other):
            return False

        for i, j in zip(self, other):
            if i != j:
                return False

        return True

注：__eq__on unicodeis definitely implemented more efficiently than this.

理性：两个对象有不同的数据，但如果有相同的关键数据，则视为相同的对象。Example：most types of model data

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
>>> import datetime
>>> a = Monitor()
>>> a.make ="Dell"
>>> a.model ="E770s"
>>> a.owner ="Bob Jones"
>>> a.warranty_expiration = datetime.date(2030, 12, 31)
>>> b = Monitor()
>>> b.make ="Dell"
>>> b.model ="E770s"
>>> b.owner ="Sam Johnson"
>>> b.warranty_expiration = datetime.date(2005, 8, 22)
>>> a is b
False
>>> a == b
True

这里，我有两个监视器，EDOCX1&24，和EDOCX1&26。他们有同样的造型和模型。然而，他们需要同样的数据，而不是记忆中的同样的对象。然而，当我们比较它们时，我们想要它们与平等的比较。这里发生的是，监测对象实现了__eq__方法。

1
2
3
4
5
class Monitor(object):
    # ...

    def __eq__(self, other):
        return self.make == other.make and self.model == other.model

回答你的问题

当与None比较时，总是使用is not。在Python中没有一个单词——记忆中只有一个单词。

通过比较身份，这可以很快地完成。Pyton checks where the object you referring to have the same memory address as the global none object-a very fast comparison of two numbers.

比如说，Python要看你的对象有__eq__方法的地方。如果不是，它检查每一个超级等级，看一个__eq__如果它找到一个，Python叫它。如果__eq__方法是缓慢的，而且当其他物体被通知为None时，不会立即返回。

你没有实现吗？然后Python很可能会找到__eq__方法，并使用它来检查对象的身份。

当比喻Python中的其他东西时，你将使用!=。

Consider the following:

1
2
3
4
5
6
7
class Bad(object):
    def __eq__(self, other):
        return True

c = Bad()
c is None # False, equivalent to id(c) == id(None)
c == None # True, equivalent to c.__eq__(None)
相关讨论

是一个单词，它的特征比较总是在工作，当一个物体通过EDOCX1模拟平等比较时。

相关讨论

ZZU1

有些物体是单数的，而这些物体等于==。几乎没有。

相关讨论