如何在 Python 中获得两个变量的逻辑异或？答案

【问题标题】：How do you get the logical xor of two variables in Python?如何在 Python 中获得两个变量的逻辑异或？
【发布时间】：2010-09-30 18:38:22
【问题描述】：

如何在 Python 中获得两个变量的logical xor？

例如，我有两个变量，我希望它们是字符串。我想测试其中只有一个包含 True 值（不是 None 或空字符串）：

str1 = raw_input("Enter string one:")
str2 = raw_input("Enter string two:")
if logical_xor(str1, str2):
    print "ok"
else:
    print "bad"

^ 运算符似乎是按位的，并没有在所有对象上定义：

>>> 1 ^ 1
0
>>> 2 ^ 1
3
>>> "abc" ^ ""
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for ^: 'str' and 'str'

【问题讨论】：

如何定义一对字符串的“异或”？你觉得 "abc" ^ "" 应该返回什么而不是？
它应该返回 True，而不是引发异常，因为只有一个字符串是 True，正如普通 Python 的 bool 类型所定义的那样。
我很惊讶 Python 没有名为“xor”的中缀运算符，这将是最直观的 Pythonic 实现。使用“^”与其他语言一致，但不像大多数 Python 那样具有明显的可读性。
@MehrdadAfshari 您的问题的明显答案是a xor a 定义为(a and not b) or (not a and b)，因此a xor b，当a 和b 是字符串或任何其他类型, 应该产生任何(a and not b) or (not a and b) 产生的结果。
问题是文档很差。 ^ 是“按位异或”，字面意思是逐位，而不是逐个布尔。所以 x'FFFF00' ^ x'FFFF00' 应该是 x'000000'。还是这只意味着逐个字符地发生？转换为数字？我们需要迭代较短的字符串字符以匹配较长字符串的长度。所有这些都应该内置。

标签： python logical-operators

【解决方案1】：

如果您已经将输入标准化为布尔值，则 != 是异或。

bool(a) != bool(b)

【讨论】：

虽然这很聪明而且很简短，但我不相信它是干净的。当有人在代码中读到这个结构时，他们是否立即明白这是一个异或操作？我觉得有必要添加评论 - 这表明我正在编写不清楚的代码并尝试通过评论道歉。
也许“很明显它是 XOR 吗？”是错误的问题。我们只是想看看两个问题的答案是否相同，并认为我们会使用 XOR 来实现它。例如，如果我们想确保不将苹果与橙子进行比较，“if xor(isApple(x), isApple(y))”真的比“if isApple(x) != isApple(y)”更清晰吗？不是我！
使用“！=”作为异或存在问题。您可能希望 bool(a) != bool(b) != bool(c) 与 bool(a) ^ bool(b) ^ bool(c) 相同。转换为 bool 也是如此，但我建议 ^.要了解第一个示例中发生了什么，请查看“运算符链接”。
@elmo：+1 指出差异，+1 教我什么是运算符链接！我在说 != 不如 ^ 可读性强的阵营中。
应该改成bool(a) is not bool(b)吗？

【解决方案2】：

您始终可以使用 xor 的定义从其他逻辑运算中计算它：

(a and not b) or (not a and b)

但这对我来说有点过于冗长，乍一看并不是特别清楚。另一种方法是：

bool(a) ^ bool(b)

两个布尔值的异或运算符是逻辑异或（与整数不同，它是按位的）。这是有道理的，因为bool is just a subclass of int，但实现为只有值0 和1。当域被限制为0 和1 时，逻辑异或等效于按位异或。

所以logical_xor 函数的实现方式如下：

def logical_xor(str1, str2):
    return bool(str1) ^ bool(str2)

归功于Nick Coghlan on the Python-3000 mailing list。

【讨论】：

很棒的帖子，但在所有命名参数的方法中，为什么要使用“str1”和“str2”？
@Token 为什么不呢。你的意思是因为它们不是很 Pythonic？
@Zach Hirsch 您能否使用 (not a and b) 而不是 (b and not a) 来提高可读性，否则定义是否与 xor 不一致。
你应该像(not b and a) or (not a and b)这样把nots放在第一位，这样如果有字符串，它就会返回字符串，这似乎是函数操作的pythonic方式。
@TokenMacGuy：你建议他给他们取什么名字？

【解决方案3】：

按位异或已经内置在 Python 中，在 operator 模块中（与 ^ 运算符相同）：

from operator import xor
xor(bool(a), bool(b))  # Note: converting to bools is essential

【讨论】：

这是我需要的。当逆向工程恶意软件时，很多时候字符串都会被破坏，直到进行 XOR 操作。使用这个 chr(xor(ord("n"), 0x1A)) = 't'
小心，这也是按位计算的：xor(1, 2) 返回3。来自文档字符串：xor(a, b) -- Same as a ^ b. 请记住，从 operator 导入的任何内容都只是现有内置中缀运算符的一种功能形式。
@askewchan：bool 类型重载__xor__ 以返回布尔值。它会工作得很好，但是当bool(a) ^ bool(b) 做同样的事情时它就过分了。
@MartijnPieters ^ 操作员在内部调用__xor__。
@Quantum7：是的，我不知道你为什么要告诉我这个。我刚才说bool 类型实现了__xor__ 方法特别是因为^ 调用它。重点是bool(a) ^ bool(b) 工作正常，这里不需要使用operator.xor() 函数。

【解决方案4】：

正如Zach 解释的，你可以使用：

xor = bool(a) ^ bool(b)

就个人而言，我更喜欢稍微不同的方言：

xor = bool(a) + bool(b) == 1

这种方言的灵感来自我在学校学习的一种逻辑图表语言，其中“OR”由包含 ≥1（大于或等于 1）的框表示，而“XOR”由包含 =1 的框表示.

这具有在多个操作数上正确实现异或的优点。

“1 = a ^ b ^ c...”表示真正操作数的数量是奇数。此运算符是“奇偶校验”。
“1 = a + b + c...”表示恰好有一个操作数为真。这是“exclusive or”，意思是“一个排除其他”。

【讨论】：

所以，True + True + False + True == 3，并且 3 != 1，但 True XOR True XOR False XOR True == True。您能否详细说明“在多个操作数上正确实现 XOR”？
@tzot 您的示例失败，因为根据 ddaa 的解决方案，您一次仅对两个变量应用加法。所以写出来的正确方法必须是(((((True + True)==1)+False)==1)+True)==1。这里给出的答案完全可以推广到多个操作数。
此外，三路异或与两个异或的操作顺序分组集之间存在差异。所以 3-WAY-XOR(A,B,C) not 与 XOR(XOR(A,B),C) 相同。 ddaa 的例子是前者，而你的假设是后者。
@Mr.F 您的解释并不能真正原谅这个答案。在 Python 中，如果你只做True + True + False + True，你做得到3，True + True + False + True == 3 回馈True，而True + True + False + True == 1 回馈False。换句话说，这里的答案没有正确概括。为此，您需要做额外的工作。同时，一个简单的True ^ True ^ False ^ True 按预期工作。
@jpmc26 我不明白你的评论。加法方法旨在概括您要检查 恰好一个 操作数是 True 的操作，这是一个多元 XOR。这是与例如A XOR B XOR ... XOR Z 不同的操作。换句话说，如果您打算使用基于加法的版本，那么在True + True + False + True 中提交操作数后，您应该期望结果为False，因为其中不止一个是True，如果条件满足检查== 1。

【解决方案5】：

Python 逻辑or:A or B：如果bool(A) 是True，则返回A，否则返回B
Python逻辑and:A and B:如果bool(A)是False，则返回A，否则返回B

为了保持这种思维方式的大部分，我的逻辑异或定义是：

def logical_xor(a, b):
    if bool(a) == bool(b):
        return False
    else:
        return a or b

这样它可以返回a、b或False：

>>> logical_xor('this', 'that')
False
>>> logical_xor('', '')
False
>>> logical_xor('this', '')
'this'
>>> logical_xor('', 'that')
'that'

【讨论】：

这对我来说似乎很糟糕，或者至少很奇怪。其他内置逻辑运算符均不返回三个可能值之一。
@Zach Hirsch：这就是为什么我说“保持大部分这种思维方式”——因为当两者都是对或错时，没有好的结果
逻辑运算必须返回逻辑值，所以第二个“返回a或b”看起来很奇怪，所以第二个返回必须返回True。
@Denis Barmenkov：好吧，请注意python 逻辑运算符and 和or 不会返回逻辑值。 'foo' and 'bar' 返回'bar' ...
乍一看，前两个答案似乎是最好的，但转念一想，这实际上是唯一真正正确的答案，即它是唯一提供xor 示例的答案实现与内置and和or一致。当然，在实际情况下，bool(a) ^ bool(b) 甚至a ^ b（如果已知a 和b 是bool）当然更简洁。

【解决方案6】：

我测试了几种方法，not a != (not b) 似乎是最快的。

这里有一些测试

%timeit not a != (not b)
10000000 loops, best of 3: 78.5 ns per loop

%timeit bool(a) != bool(b)
1000000 loops, best of 3: 343 ns per loop

%timeit not a ^ (not b)
10000000 loops, best of 3: 131 ns per loop

编辑： 上面的示例 1 和 3 缺少括号，因此结果不正确。新结果 + truth() 按照 ShadowRanger 的建议发挥作用。

%timeit  (not a) ^  (not b)   # 47 ns
%timeit  (not a) != (not b)   # 44.7 ns
%timeit truth(a) != truth(b)  # 116 ns
%timeit  bool(a) != bool(b)   # 190 ns

【讨论】：

那是我生命中的 100 纳秒，我不会回来 ;-)
对于中间时间，您可以在模块顶部执行from operator import truth，并测试truth(a) != truth(b)。 bool 作为构造函数在 C 级别有很多不可避免的开销（它必须接受与 *args, **kwargs 等效的参数并解析 tuple 和 dict 以提取它们），其中 truth（作为函数）可以使用不需要tuple 或dict 的优化路径，并且运行时间约为基于bool 的解决方案的一半（但仍比基于not 的解决方案更长）。跨度>
这是指哪个 Python 实现的版本？
@LutzPrechelt 不幸的是我不记得了；大概 3.5

【解决方案7】：

Python 有一个按位异或运算符，它是^：

>>> True ^ False
True
>>> True ^ True
False
>>> False ^ True
True
>>> False ^ False
False

您可以通过在应用异或 (^) 之前将输入转换为布尔值来使用它：

bool(a) ^ bool(b)

（已编辑 - 感谢 Arel）

【讨论】：

您的答案应该清楚地表明^ 是一个按位 xor（不像所问的问题那样是逻辑xor）。 bool(2) ^ bool(3) 给出的答案与 bool(2 ^ 3) 不同。
@Arel 但事实并非如此。 a ^ b 是多态。如果a 和b 是bool 实例，则结果也将是bool。这种行为很难被称为“按位”异或。
@Alfe 重要的一点是 值必须首先转换为布尔值。 Python 文档将 ^ 定义为按位，尽管保留类型是一个有趣的点对于bool 和int 类型。注意：True ^ 2 是3，证明它确实是按位的。
@Arel 是的，bool ^ int 的情况是先将所有内容都转换为int。尽管如此，Python 为int 中的许多位和bool 中表示的一位内置了^ 运算符，因此两者都是bitwise，但bitwise xor for a single bit is logical xor for booleans.
我一直讨厌使用这个运算符，虽然我知道它是xor，来自工程背景，但对我来说，这本能地感觉像是一种数学力量，即2^3 = pow(2,3)，这意味着我总是明确地评论以防止混淆。

【解决方案8】：

简单易懂：

sum(bool(a), bool(b)) == 1

如果您需要一个独占选择，即从n 中选择1，则可以将其扩展为多个参数：

sum(bool(x) for x in y) == 1

【讨论】：

sum(map(bool, y)) % 2 == 1
如果你只有 2 个变量，我看不出使用 sum 的理由，bool(a) + bool(b) == 1 做同样的事情。
@Boris Potayto potarto
@cz 我很高兴你同意一个明显错的:)

【解决方案9】：

由于我没有看到使用可变参数的 xor 的简单变体，并且仅对真值 True 或 False 进行操作，因此我将把它扔在这里供任何人使用。正如其他人所指出的那样，非常（不是说非常）简单明了。

def xor(*vars):
    result = False
    for v in vars:
        result = result ^ bool(v)
    return result

而且用法也很简单：

if xor(False, False, True, False):
    print "Hello World!"

由于这是广义的 n 元逻辑 XOR，只要 True 操作数的数量为奇数，其真值将为 True（不仅当恰好一个为 True 时，这只是 n 元 XOR 的一种情况真的）。

因此，如果您正在寻找一个 n 元谓词，该谓词仅在其中一个操作数为真时才为真，您可能希望使用：

def isOne(*vars):
    result = False
    for v in vars:
        if result and v:
            return False
        else:
            result = result or v
    return result

【讨论】：

为了改进这个答案：(bool(False) is False) == True。您可以在这些行上使用False。

【解决方案10】：

打赏帖：

阳极的想法...只要你尝试（可能是）pythonic表达式«is not»以获得逻辑«xor»的行为

真值表是：

>>> True is not True
False
>>> True is not False
True
>>> False is not True
True
>>> False is not False
False
>>>

对于您的示例字符串：

>>> "abc" is not  ""
True
>>> 'abc' is not 'abc' 
False
>>> 'abc' is not '' 
True
>>> '' is not 'abc' 
True
>>> '' is not '' 
False
>>>

但是；正如他们上面所指出的，这取决于你想要提取的任何一对字符串的实际行为，因为字符串不是布尔值......甚至更多：如果你«Dive Into Python»，您会发现«The Peculiar Nature of "和”和“或”» http://www.diveintopython.net/power_of_introspection/and_or.html

对不起，我写的英语不是我的母语。

问候。

【讨论】：

我也习惯将其解读为“完全不同”。这是因为某些语言使用二进制表示逐位实现运算，并采用结果按位运算的布尔值。我猜你的答案更“防弹”，因为它超出了布尔空间。
我的意思是，您的答案涵盖了比较 None、False、'' 的情况，因为不同的是与众不同的东西。例如： bool(False) != bool('') 然而 False is not ''" 更符合这种“完全不同”的语义

【解决方案11】：

我知道这已经晚了，但我有一个想法，这可能是值得的，只是为了记录。也许这会起作用：np.abs(x-y) 这个想法是

如果 x=True=1 和 y=False=0 那么结果将是 |1-0|=1=True
如果 x=False=0 和 y=False=0 那么结果将是 |0-0|=0=False
如果 x=True=1 和 y=True=1 那么结果将是 |1-1|=0=False
如果 x=False=0 且 y=True=1，则结果为 |0-1|=1=True

【讨论】：

你甚至可以放弃abs，python 将负数解释为真实，尽管这在 imo 中非常模糊（if (x > 1) - (y > 3) 是什么意思？

【解决方案12】：

在 Python 中获取两个或多个变量的逻辑异或：

将输入转换为布尔值
使用按位异或运算符（^ 或 operator.xor）

例如，

bool(a) ^ bool(b)

当您将输入转换为布尔值时，bitwise xor 变为 logical xor。

请注意，接受的答案是错误的： != 与 Python 中的 xor 不同，因为 运算符链 的微妙之处。

例如，使用!=时，下面三个值的异或是错误的：

True ^  False ^  False  # True, as expected of XOR
True != False != False  # False! Equivalent to `(True != False) and (False != False)`

（附注：我尝试编辑接受的答案以包含此警告，但我的更改被拒绝。）

【讨论】：

【解决方案13】：

异或定义如下

def xor( a, b ):
    return (a or b) and not (a and b)

【讨论】：

这将为 xor('this', '') 返回 True 并遵循 python 的方式，它应该返回 'this'。
@nosklo：请接受 BDFL，而不是我。由于 Python 返回 True，那么必须是 Python 的方式。
我的意思是为了与其他 Python 逻辑运算符保持一致——当我这样做时 Python 不返回 True（'this' 或 ''），它返回 'this'。但是在你的函数中 xor('this', '') 返回 True。它应该像“或”python内置函数一样返回“this”。
Python and 和 or 做短路。任何xor的实现都不能短路，所以已经有出入；因此，xor 没有理由像 and+or 那样运作。

【解决方案14】：

这里建议的一些实现在某些情况下会导致操作数的重复评估，这可能会导致意想不到的副作用，因此必须避免。

也就是说，返回True 或False 的xor 实现相当简单；如果可能的话，返回其中一个操作数的方法要复杂得多，因为对于应该选择哪个操作数没有共识，尤其是当有两个以上的操作数时。例如，xor(None, -1, [], True) 应该返回None、[] 还是False？我敢打赌，每个答案在某些人看来都是最直观的。

对于真或假结果，有多达五种可能的选择：返回第一个操作数（如果它与最终结果的值匹配，否则为布尔值），返回第一个匹配项（如果至少存在一个，否则boolean），返回最后一个操作数（if ... else ...），返回最后一个匹配项（if ... else ...），或者总是返回布尔值。总共有 5 ** 2 = 25 种 xor。

def xor(*operands, falsechoice = -2, truechoice = -2):
  """A single-evaluation, multi-operand, full-choice xor implementation
  falsechoice, truechoice: 0 = always bool, +/-1 = first/last operand, +/-2 = first/last match"""
  if not operands:
    raise TypeError('at least one operand expected')
  choices = [falsechoice, truechoice]
  matches = {}
  result = False
  first = True
  value = choice = None
  # avoid using index or slice since operands may be an infinite iterator
  for operand in operands:
    # evaluate each operand once only so as to avoid unintended side effects
    value = bool(operand)
    # the actual xor operation
    result ^= value
    # choice for the current operand, which may or may not match end result
    choice = choices[value]
    # if choice is last match;
    # or last operand and the current operand, in case it is last, matches result;
    # or first operand and the current operand is indeed first;
    # or first match and there hasn't been a match so far
    if choice < -1 or (choice == -1 and value == result) or (choice == 1 and first) or (choice > 1 and value not in matches):
      # store the current operand
      matches[value] = operand
    # next operand will no longer be first
    first = False
  # if choice for result is last operand, but they mismatch
  if (choices[result] == -1) and (result != value):
    return result
  else:
    # return the stored matching operand, if existing, else result as bool
    return matches.get(result, result)

testcases = [
  (-1, None, True, {None: None}, [], 'a'),
  (None, -1, {None: None}, 'a', []),
  (None, -1, True, {None: None}, 'a', []),
  (-1, None, {None: None}, [], 'a')]
choices = {-2: 'last match', -1: 'last operand', 0: 'always bool', 1: 'first operand', 2: 'first match'}
for c in testcases:
  print(c)
  for f in sorted(choices.keys()):
    for t in sorted(choices.keys()):
      x = xor(*c, falsechoice = f, truechoice = t)
      print('f: %d (%s)\tt: %d (%s)\tx: %s' % (f, choices[f], t, choices[t], x))
  print()

【讨论】：

【解决方案15】：

有时我发现自己使用 1 和 0 而不是布尔 True 和 False 值。在这种情况下，xor 可以定义为

z = (x + y) % 2

有如下真值表：

     x
   |0|1|
  -+-+-+
  0|0|1|
y -+-+-+
  1|1|0|
  -+-+-+

【讨论】：

【解决方案16】：

很多人，包括我自己，都需要一个 xor 函数，该函数的行为类似于 n 输入异或电路，其中 n 是可变的。（见https://en.wikipedia.org/wiki/XOR_gate）。下面的简单函数实现了这一点。

def xor(*args):
   """
   This function accepts an arbitrary number of input arguments, returning True
   if and only if bool() evaluates to True for an odd number of the input arguments.
   """

   return bool(sum(map(bool,args)) % 2)

示例 I/O 如下：

In [1]: xor(False, True)
Out[1]: True

In [2]: xor(True, True)
Out[2]: False

In [3]: xor(True, True, True)
Out[3]: True

【讨论】：

【解决方案17】：

这个怎么样？

(not b and a) or (not a and b)

如果b 为假，将给出a
如果a 为假，将给出b
否则将给False

或者使用 Python 2.5+ 三元表达式：

(False if a else b) if b else a

【讨论】：

【解决方案18】：

Xor 在 Python 中是 ^。它返回：

整数的按位异或
布尔的逻辑异或
集合的排他并集
实现__xor__的类的用户定义结果。
未定义类型（例如字符串或字典）的 TypeError。

如果您仍然打算在字符串上使用它们，将它们转换为 bool 会使您的操作明确（您也可以表示 set(str1) ^ set(str2)）。

【讨论】：

【解决方案19】：

这就是我编写任何真值表的方式。特别是对于 xor，我们有：

| a | b  | xor   |             |
|---|----|-------|-------------|
| T | T  | F     |             |
| T | F  | T     | a and not b |
| F | T  | T     | not a and b |
| F | F  | F     |             |

只需查看答案列中的 T 值，然后用逻辑或将所有真实情况串在一起。所以，这个真值表可能会在情况 2 或 3 中产生。因此，

xor = lambda a, b: (a and not b) or (not a and b)

【讨论】：

【解决方案20】：

当您知道 XOR 的作用时，这很容易：

def logical_xor(a, b):
    return (a and not b) or (not a and b)

test_data = [
  [False, False],
  [False, True],
  [True, False],
  [True, True],
]

for a, b in test_data:
    print '%r xor %s = %r' % (a, b, logical_xor(a, b))

【讨论】：

【解决方案21】：

这将获得两个（或更多）变量的逻辑异或

str1 = raw_input("Enter string one:")
str2 = raw_input("Enter string two:")

any([str1, str2]) and not all([str1, str2])

此设置的第一个问题是它很可能会遍历整个列表两次，并且至少会检查至少一个元素两次。因此它可能会提高代码理解能力，但不会提高速度（根据您的用例，差异可能可以忽略不计）。

此设置的第二个问题是，无论变量数量如何，它都会检查排他性。这最初可能被视为一个特征，但随着变量数量的增加（如果有的话），第一个问题变得更加重要。

【讨论】：

【解决方案22】：

XOR 在operator.xor 中实现。

【讨论】：

operator.xor 对应的是按位运算，这是原帖不想要的。
@kojiro evidently so!

【解决方案23】：

鉴于 A 和 B 是布尔值。

A is not B

【讨论】：

【解决方案24】：

您使用与 C 中相同的 XOR 运算符，即 ^。

我不知道为什么，但最赞成的解决方案建议bool(A) != bool(B)，而我想说 - 与 C 的^ 的运算符一致，最明显的解决方案是：

bool(A) ^ bool(B)

对于来自C 或任何C 派生语言的任何人来说，它更具可读性和可立即理解...

在打代码打高尔夫球时，可能

not A ^ (not B)

将成为赢家。使用not 作为布尔值的转换器（比bool() 少一个字母。对于第一个表达式，在某些情况下可以省略括号。好吧，这取决于，在必须做not(A) ^ (not(B)) 的情况下，@ 987654331@ 需要相同数量的字母...

【讨论】：

not not A 是另一种无需函数调用即可获得与bool(A) 相同结果的方法。

【解决方案25】：

只是因为我没有在其他地方看到它，所以这也可以解决问题：

def logical_xor(a, b):
    return not b if a else bool(b)

我不确定它是否比公认的解决方案 bool(a) != bool(b)“更好”/更具可读性/更 Pythonic。

【讨论】：

【解决方案26】：

Python 处理逻辑操作的方式可能会令人困惑，因此我的实现为用户提供了一个简单的 True/False 答案选项（默认情况下）。可以通过将可选的第三个参数设置为 None 来获得实际的 Python 结果。

def xor(a, b, true=True, false=False): # set true to None to get actual Python result
    ab1 = a and not b
    ab2 = not a and b
    if bool(ab1) != bool(ab2):
        return (ab1 or ab2) if true is None else true
    else:
        return false

【讨论】：

【解决方案27】：

我们可以很容易地通过 using 找到两个变量的异或：

def xor(a,b):
    return a !=b

例子：

xor(True,False) >>> 真

【讨论】：

或xor("hey", "there") >>> 没错，但这不是我们想要的