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

简单易懂：

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

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

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

---

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

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

例如，

bool(a) ^ bool(b)

当您将输入转换为布尔值时，按位异或变为逻辑异或。

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

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

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

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

---

由于我没有看到使用变量参数的 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 为 True 的一种情况）。

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

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

---

奖励线程：

阳极的想法......只是你尝试（可能是）pythonic表达式«不是»以获得逻辑«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
>>> 

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

对不起，我的书面英语，它不是我出生的语言。

问候。

---

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

如果 x=True=1 和 y=False=0 则结果为 |1-0|=1=True 如果 x=False=0 且 y=False=0 则结果为 |0-0|=0 =False if x=True=1 and y=True=1 then the result will be |1-1|=0=False if x=False=0 and y=True=1 then the result will be |0-1| =1=真

---

鉴于 A 和 B 是布尔值。

A is not B

---

异或定义如下

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

---

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

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

对于真或假结果，有多达五种可能的选择：返回第一个操作数（如果它与最终结果的值匹配，否则为布尔值），返回第一个匹配项（如果至少存在一个，则为布尔值），返回最后一个操作数（如果 ... else ...），返回最后一个匹配项（如果 ... 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()

---

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

z = (x + y) % 2

它具有以下真值表：

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

---

许多人，包括我自己，都需要一个 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

---

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

我不知道为什么，但最受好评的解决方案建议 bool(A) != bool(B)，而我会说 - 按照 C 的 ^ 运算符，最明显的解决方案是：

bool(A) ^ bool(B)

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

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

not A ^ (not B)

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

---

这个怎么样？

(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

---

Xor 在 Python 中是 ^。它返回：

整数的按位异或

布尔的逻辑异或

集的排他并集

实现 __xor__ 的类的用户定义结果。

未定义类型的 TypeError，例如字符串或字典。

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

---

这就是我编写任何真值表的方式。特别是对于 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)

---

当您知道 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))

---

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

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

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

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

此设置的第二个问题是它会检查排他性，而不考虑变量的数量。起初这可能被视为一个特征，但随着变量数量的增加（如果它们曾经这样做的话），第一个问题变得更加重要。

---

XOR 在 operator.xor 中实现。

---

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

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

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

---

Python 处理逻辑操作的方式可能会令人困惑，因此我的实现为用户提供了一个简单的 True/False 答案选项（默认情况下）。可以通过将可选的第三个 arg 设置为 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

---

这是一个概括。

def xor(*orands):
    return sum(bool(x) for x in orands) == 1

你可以用

# test
from itertools import product
for a, b, c in product((False, True), repeat=3):
    print(f'{int(a)}{int(b)}{int(c)}|{xor(a,b,c)}')

输出：

000|假 001|真 010|真 011|假 100|真 101|假 110|假 111|假

---

我们可以通过使用轻松找到两个变量的异或：

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

例子：

异或（真，假）>>> 真

---