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

我没有看到使用可变参数并仅对真值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元逻辑异或，只有当True操作数的数量为奇数时（不仅仅是当只有一个为True时），它的真值才为True。

因此，如果你正在寻找一个只有在它的操作数中恰好有一个为True时才为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表达式来获得逻辑“异或”的行为

真值表如下：

>>> 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”，您将发现“and”和“or”的奇特性质。

http://www.diveintopython.net/power_of_introspection/and_or.html

抱歉我的英语写作，这不是我的母语。

敬礼。

您使用与C语言相同的XOR运算符，即^。
我不知道为什么，但最受欢迎的解决方案建议使用bool(A) != bool(B)，而我会说 - 与C的^运算符相一致，最明显的解决方案是：

bool(A) ^ bool(B)

对于那些使用C或类似C语言的人来说，更易读且立即理解...

在进行代码高尔夫时，可能会使用。

not A ^ (not B)

使用 not 作为布尔值的转换器，将会成为胜者（比 bool() 少一个字母）。在某些情况下，可以省略第一个表达式中的括号。当需要执行 not(A) ^ (not(B)) 时，则需要使用 bool() 的相同字母数...

我知道这有点晚了，但我有一个想法，也许值得记录一下。或许这个方法可以行：np.abs(x-y)。这个想法是：

1. 如果x=True=1而y=False=0，则结果为|1-0|=1=True
2. 如果x=False=0而y=False=0，则结果为|0-0|=0=False
3. 如果x=True=1而y=True=1，则结果为|1-1|=0=False
4. 如果x=False=0而y=True=1，则结果为|0-1|=1=True

许多人，包括我自己，需要一个行为类似于n输入异或电路的xor函数，其中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)

以下是样例输入输出：

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

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

话虽如此，一个返回True或False的xor实现相当简单；如果可能的话，返回其中一个操作数则要困难得多，因为没有共识可以选择哪个操作数，特别是当有两个以上的操作数时。例如，xor(None, -1, [], True)应该返回None、[]还是False？我敢打赌每个答案都会被一些人认为是最直观的。

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

异或（Exclusive Or）的定义如下：

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

有时我会使用1和0而不是布尔值True和False。在这种情况下，异或可以定义为：

z = (x + y) % 2

这个真值表如下：

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

以下是我编写任何真值表的代码方式。对于异或运算，我们有：

| 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)

这个怎么样？

(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