Python &引用；x不在"；vs.“；不是“x”中的“x”；

我注意到这两种方法都是一样的：

如果x不在列表中

和

如果x不在列表中

在某些情况下，两者之间有什么区别吗？两者兼有是有原因的，还是仅仅因为有些人写一个或另一个更自然

---

我更可能在别人的代码中看到哪一个？

这只是个人偏好。如果x！=3和

如果不是x==3

。你所展示的两种表达方式没有区别。

这只是个人偏好。如果x！=3和

如果不是x==3

。您显示的两个表达式之间没有区别。

不是L中的x

并没有被明确禁止，因为这样做很愚蠢<不在L中的code>x是明确允许的（尽管它编译为相同的字节码），因为它更具可读性

---

x不在L中

是每个人都会使用的。

不在L中的x

并没有被明确禁止，因为那会很愚蠢<不在L中的code>x是明确允许的（尽管它编译为相同的字节码），因为它更具可读性

---

x不在L

是每个人都使用的。当你写

a不在b

时，它使用

not in

操作符，而

not a in b

使用

in

操作符，然后否定结果。但是

not in

操作符被定义为返回与b中的

not a相同的值，因此它们执行完全相同的操作。从：

操作员
在
和
不在
测试集合成员资格<如果
x
是集合
s
的成员，则s

中的code>x计算为true，否则为false

x not in s

返回s中x的反运算

同样地，

a不是b

与

不是a是b

---

添加额外的语法是因为它使人更容易自然地阅读。

当您编写

a not in b

时，它使用

not in

运算符，而

not a in b

使用

in

运算符，然后对结果求反。但是

not in

操作符被定义为返回与b中的

not a相同的值，因此它们执行完全相同的操作。从：

>>> dis.dis(lambda: a not in b)
1           0 LOAD_GLOBAL              0 (a)
          3 LOAD_GLOBAL              1 (b)
          6 COMPARE_OP               7 (not in)
          9 RETURN_VALUE      

>>> dis.dis(lambda: not a in b)
1           0 LOAD_GLOBAL              0 (a)
          3 LOAD_GLOBAL              1 (b)
          6 COMPARE_OP               7 (not in)
          9 RETURN_VALUE  

操作员
在
和
不在
测试集合成员资格<如果
x
是集合
s
的成员，则s

中的code>x计算为true，否则为false

x not in s

返回s中x的反运算

同样地，

a不是b

与

不是a是b

增加了额外的语法，因为它使人更容易自然地阅读

>>> dis.dis(lambda: a not in b)
1           0 LOAD_GLOBAL              0 (a)
          3 LOAD_GLOBAL              1 (b)
          6 COMPARE_OP               7 (not in)
          9 RETURN_VALUE      

>>> dis.dis(lambda: not a in b)
1           0 LOAD_GLOBAL              0 (a)
          3 LOAD_GLOBAL              1 (b)
          6 COMPARE_OP               7 (not in)
          9 RETURN_VALUE  

如果您不选择“b中的非a”，则需要将其转换为（非b中的）

因此，正确的方法是“a不在b中”

如果您不选择“b中的非a”，则需要将其转换为（非b中的）

---

因此，正确的方法是“a不在b中”。

这两种形式构成相同的字节码，您可以清楚地验证：

>>> import dis
>>> dis.dis(compile('if x not in d: pass', '', 'exec'))
  1           0 LOAD_NAME                0 (x)
              3 LOAD_NAME                1 (d)
              6 COMPARE_OP               7 (not in)
              9 JUMP_IF_FALSE            4 (to 16)
             12 POP_TOP             
             13 JUMP_FORWARD             1 (to 17)
        >>   16 POP_TOP             
        >>   17 LOAD_CONST               0 (None)
             20 RETURN_VALUE        
>>> dis.dis(compile('if not x in d: pass', '', 'exec'))
  1           0 LOAD_NAME                0 (x)
              3 LOAD_NAME                1 (d)
              6 COMPARE_OP               7 (not in)
              9 JUMP_IF_FALSE            4 (to 16)
             12 POP_TOP             
             13 JUMP_FORWARD             1 (to 17)
        >>   16 POP_TOP             
        >>   17 LOAD_CONST               0 (None)
             20 RETURN_VALUE        

很明显，它们在语义上是相同的

作为一种风格，没有提到这个问题

---

就我个人而言，我非常喜欢

如果x不在y中

的形式，这就立即清楚地表明

不在

中是一个单独的操作符，和“读起来像英语”

if not x in y

可能会误导一些读者，使他们认为它的意思是

if（not x）in y

，读起来有点不像英语，而且绝对没有任何补偿优势。

这两种形式构成相同的字节码，您可以清楚地验证：

>>> import dis
>>> dis.dis(compile('if x not in d: pass', '', 'exec'))
  1           0 LOAD_NAME                0 (x)
              3 LOAD_NAME                1 (d)
              6 COMPARE_OP               7 (not in)
              9 JUMP_IF_FALSE            4 (to 16)
             12 POP_TOP             
             13 JUMP_FORWARD             1 (to 17)
        >>   16 POP_TOP             
        >>   17 LOAD_CONST               0 (None)
             20 RETURN_VALUE        
>>> dis.dis(compile('if not x in d: pass', '', 'exec'))
  1           0 LOAD_NAME                0 (x)
              3 LOAD_NAME                1 (d)
              6 COMPARE_OP               7 (not in)
              9 JUMP_IF_FALSE            4 (to 16)
             12 POP_TOP             
             13 JUMP_FORWARD             1 (to 17)
        >>   16 POP_TOP             
        >>   17 LOAD_CONST               0 (None)
             20 RETURN_VALUE        

很明显，它们在语义上是相同的

作为一种风格，没有提到这个问题

---

就我个人而言，我非常喜欢

如果x不在y中

的形式，这就立即清楚地表明

不在

中是一个单独的操作符，和“读起来像英语”

if not x in y

可能会误导一些读者，使他们认为它的意思是

if（not x）in y

，读起来有点不像英语，而且绝对没有任何补偿优势。

这两种说法不尽相同<代码>=调用

\uuu ne\uuu

和

==

调用

\uuu eq\uuu

。在反常的情况下，你的例子可能会有不同的结果。我应该加上一句，“不谈变态”！这些是不一样的<代码>=调用

\uuu ne\uuu

和

==

调用

\uuu eq\uuu

。在反常的情况下，你的例子可能会有不同的结果。我应该加上一句，“不谈变态”！奇怪的部分是当您使用

dis

模块时，它表明无论文档怎么说，它们都使用

而不是
进行比较…奇怪的部分是当您使用
dis
模块时，这表明，无论文档怎么说，他们都使用
而不是
进行比较……完全可以接受将旧问题作为新问题的副本来结束。你看，把一个老问题当作一个新问题的重复来解决是完全可以接受的。请参阅，PEP 8提到了一个类似的首选项：“使用
不是
运算符，而不是
不是…是
。虽然两个表达式在功能上相同，但前者更具可读性和首选性。”PEP 8提到了一个类似的首选项：“使用
is not
运算符而不是
not…is
。虽然两个表达式在功能上完全相同，但前者更具可读性且更可取。”