python运算符，没有用于“的运算符”；不在「；

这可能是一个愚蠢的问题，但我注意到在操作符中没有表示

的函数。起初，我认为这可能是因为解释器只是将其重新排序为
而不是y中的x
，但是有一个函数用于
不是
，它的行为应该与
不在
中的行为完全相同。是我遗漏了什么，还是那个操作员真的不存在

这里有一个非常愚蠢的例子，你可能想要这个：

def compare_iter(a,b,func):
    return [func(aa,bb) for aa,bb in zip(a,b)]

my_compare=compare_iter(xx,yy,lambda x,y:x not in y)  #lambda -- yuck
my_compare=map(operator.not_,compare_iter(xx,yy,operator.contains)  #extra map?  grr...
#it would be nice to do: my_compare=compare_iter(xx,yy,operator.not_contains)

当然，我可以为此编写自己的函数，但这样做会付出效率上的代价，而操作符模块可以将此代码从python中推出，因此执行速度更快。
这里不需要另一个函数
not in
与
中的
相反，因此有以下映射：

obj in seq => contains(seq, obj)

obj not in seq => not contains(seq, obj)

你是对的，这与
is
/
is not
不一致，因为身份测试应该是对称的。这可能是一个设计工件。
您可能会发现以下函数和反汇编有助于理解运算符：

>>> def test():
        if 0 in (): pass
        if 0 not in (): pass
        if 0 is (): pass
        if 0 is not (): pass
        return None

>>> dis.dis(test)
  2           0 LOAD_CONST               1 (0) 
              3 LOAD_CONST               2 (()) 
              6 COMPARE_OP               6 (in) 
              9 POP_JUMP_IF_FALSE       15 
             12 JUMP_FORWARD             0 (to 15) 

  3     >>   15 LOAD_CONST               1 (0) 
             18 LOAD_CONST               3 (()) 
             21 COMPARE_OP               7 (not in) 
             24 POP_JUMP_IF_FALSE       30 
             27 JUMP_FORWARD             0 (to 30) 

  4     >>   30 LOAD_CONST               1 (0) 
             33 LOAD_CONST               4 (()) 
             36 COMPARE_OP               8 (is) 
             39 POP_JUMP_IF_FALSE       45 
             42 JUMP_FORWARD             0 (to 45) 

  5     >>   45 LOAD_CONST               1 (0) 
             48 LOAD_CONST               5 (()) 
             51 COMPARE_OP               9 (is not) 
             54 POP_JUMP_IF_FALSE       60 
             57 JUMP_FORWARD             0 (to 60) 

  6     >>   60 LOAD_CONST               0 (None) 
             63 RETURN_VALUE         
>>> 

正如您所看到的，每个操作符都有差异；他们的代码（顺序）是6、7、8和9。
事实上，
a不是b
难道不能简单地重新排序为
不是a是b
？是否存在这样的情况，即检查
不在
中可能比检查
在
中更快，因为根据定义，
不在
是一个彻底的搜索。@JAB--是的，它可以。但这不是重点。关键是这里有一个不对称，这有点可笑。似乎应该有一个
not_contains
函数，然后可以用来传递给其他函数或其他任何函数（而不是依赖
lambda
）。想想Bloom过滤器之类的东西，如果只设置了一个位，您可以确定该项没有插入到集合中。是的，但是如果您在（）中设置了
not 0
，它会将其转换为
0 not in（）
——这让我更加想到，操作员模块中应该有一个对应的操作员，因为
而不是
显然是口译员的一个独特（甚至是首选）操作员…@mgilson：我刚刚注意到了这一点。我原以为会是另一种情况，但事实上我现在同意你的观点。有趣的是，我似乎找不到任何关于将
not in
作为
operator
的成员包含在官方Python邮件列表中的讨论，尽管有关于它的有用性的讨论。@JAB，你能发一个链接到一些关于有用性的讨论吗？（这个问题对我来说主要是学术性的，我很想看看其他人对实际用例的看法）有没有办法要求添加它？我想让
不在
中使用一个字节码比先在
中计算
，然后再在
中计算
不在
中更有效，在我看来，应该需要另一个接线员
x>y
并不（必然）意味着
not（x