如何在Python中获得两个变量的逻辑异或?
例如，我有两个变量，我希望它们是字符串。我想测试它们中只有一个包含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'
当前回答
这是映射-缩减泛化的实现。注意，这相当于functools。Reduce (lambda x, y: x != y, map(bool, orands))。
def xor(*orands):
return bool(sum(bool(x) for x in orands) % 2)
如果你在寻找一个单一热点探测器，这是一个概括。这种概括可能适用于英语中exclusive-or的用法(例如:“花一美元，你可以买一杯果汁、咖啡或茶”)，但这与典型的操作顺序不符。E.g.xor_1hot (1 1 1) = = 0 ! = 1 = = xor_1hot (xor_1hot(1, 1), 1)。
def xor_1hot(*orands):
return sum(bool(x) for x in orands) == 1
你可以用
# test
from itertools import product
n = 3
total_true = 0
for inputs in product((False, True), repeat=n):
y = xor(*inputs)
total_true += int(y)
print(f"{''.join(str(int(b)) for b in inputs)}|{y}")
print('Total True:', total_true)
单热检测器输出:
000 |假 001 |真 010 |真 011 |假 100 |真 101 |假 110 |假 111 |假 总数正确:3
使用映射-规约模式输出:
000 |假 001 |真 010 |真 011 |假 100 |真 101 |假 110 |假 111 |真 总数:4
其他回答
只是因为我没有在其他地方看到过它，这也是一个诀窍:
def logical_xor(a, b):
return not b if a else bool(b)
我不确定它是否比公认的解决方案bool(a) != bool(b)“更好”/更可读/更python化。
这里建议的一些实现在某些情况下会导致操作数的重复求值，这可能会导致意想不到的副作用，因此必须避免。
也就是说，一个返回True或False的xor实现相当简单;如果可能的话，返回其中一个操作数的方法要棘手得多，因为对于应该选择哪个操作数没有共识，特别是当有两个以上的操作数时。例如，xor(None， -1， []， True)是否应该返回None，[]或False?我敢打赌，每个答案对某些人来说都是最直观的。
对于True-或false -结果，有多达五种可能的选择:返回第一个操作数(如果它在value中匹配最终结果，否则布尔值)，返回第一个匹配(如果至少存在一个，否则布尔值)，返回最后一个操作数(如果…Else…)，返回最后一次匹配(if…Else…)，或者总是返回boolean。总共是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()
这个怎么样?
(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:
def xor(a,b):
return a !=b
例子:
xor(真，假)>>真
按位异或已经内置在Python的operator模块中(与^ operator相同):
from operator import xor
xor(bool(a), bool(b)) # Note: converting to bools is essential
