Python bitand (&) vs and答案

【问题标题】：Python bitand (&) vs andPython bitand (&) vs and
【发布时间】：2013-03-06 15:17:55
【问题描述】：

大家好，我有这部分代码：

for line in response.body.split("\n"):
    if line != "": 
        opg = int(line.split(" ")[2])
        opc = int(line.split(" ")[3])
        value = int(line.split(" ")[5])
        if opg==160 & opc==129:
            ret['success'] = "valore: %s" % (value)
            self.write(tornado.escape.json_encode(ret))

我有一系列的线型

1362581670        2459546910990453036    156     0     30      0

我只想取第三个和第四个元素分别为 160 和 129 的行。此代码不起作用。我必须做一些铸造吗？我认为 opg==160 正在努力将 int 与 int 进行比较...

【问题讨论】：

那些看起来像制表符，而不是空格——对吗？
& 没有做你认为的事情。使用and。
按照你的数据格式，说line.split(" ")，它只会在一个空格之后分割，而不是那个选项卡。如果这导致了问题，您应该尝试删除数据之间的选项卡，使其看起来像 1362581670 2459546910990453036 156 0 30 0

标签： python bitwise-operators logical-and

【解决方案1】：

您对运算符感到困惑； and is the correct boolean test, & 是binary bitwise operator：

if opg == 160 and opc == 129:

作为数字运算符，& 运算符具有higher precedence than comparison operators，而布尔运算符的优先级较低。表达式 opg == 160 & opc == 129 因此被解释为 opg == (160 & opc) == 129，这可能不是您想要的。

你可以稍微简化你的代码：

for line in response.body.splitlines():
    if line:
        line = map(int, line.split())
        opg, opc, value = line[2], line[3], line[5]
        if opg == 160 and opc == 129:
            ret['success'] = "valore: %s" % (value)
            self.write(tornado.escape.json_encode(ret))

【讨论】：

【解决方案2】：

只需使用line.split() 而不是line.split(" ")。这样它就可以处理任何类型的空白。如果这些不仅仅是空格，你会得到一些奇怪的结果，这可能就是正在发生的事情。

【讨论】：

不，int() 调用会忽略多余的空格。
@MartijnPieters -- 是的，但是"1_____2".split(" ")[1] 甚至没有给你一些“intable”（其中_ 代表空格）

【解决方案3】：

& 是按位运算。你可能想要and。使用整数，您可能不会认为它会有所作为

>>> True & False
False
>>> True & True
True
>>> False & False
False

但是，请注意 & 和 and 有 different priorities。

>>> opc,opg = 160,129
>>> opc == 160 & opg == 129
False
>>> opc == 160 and opg == 129
True

基本上，& 比 == 绑定得更紧密，所以 a == b & c == d 被解析为 a == ( b & c) == d 而不是 (a == b) & (c == d)，就像你想要的那样。

>>> def func1():
...     opc,opg = 160,129
...     opc == 160 & opg == 129
... 
>>> def func2():
...     opc,opg = 160,129
...     opc == 160 and opg == 129
... 
>>> import dis
>>> dis.dis(func1)
  2           0 LOAD_CONST               3 ((160, 129))
              3 UNPACK_SEQUENCE          2
              6 STORE_FAST               0 (opc)
              9 STORE_FAST               1 (opg)

  3          12 LOAD_FAST                0 (opc)
             15 LOAD_CONST               1 (160)
             18 LOAD_FAST                1 (opg)
             21 BINARY_AND          
             22 DUP_TOP             
             23 ROT_THREE           
             24 COMPARE_OP               2 (==)
             27 JUMP_IF_FALSE_OR_POP    39
             30 LOAD_CONST               2 (129)
             33 COMPARE_OP               2 (==)
             36 JUMP_FORWARD             2 (to 41)
        >>   39 ROT_TWO             
             40 POP_TOP             
        >>   41 POP_TOP             
             42 LOAD_CONST               0 (None)
             45 RETURN_VALUE        
>>> dis.dis(func2)
  2           0 LOAD_CONST               3 ((160, 129))
              3 UNPACK_SEQUENCE          2
              6 STORE_FAST               0 (opc)
              9 STORE_FAST               1 (opg)

  3          12 LOAD_FAST                0 (opc)
             15 LOAD_CONST               1 (160)
             18 COMPARE_OP               2 (==)
             21 JUMP_IF_FALSE_OR_POP    33
             24 LOAD_FAST                1 (opg)
             27 LOAD_CONST               2 (129)
             30 COMPARE_OP               2 (==)
        >>   33 POP_TOP             
             34 LOAD_CONST               0 (None)
             37 RETURN_VALUE

正如 Hoopdady 所指出的，您也没有正确拆分字符串。 line.split() 或 line.split(None) 将在连续运行的空白处拆分。

【讨论】：