Algumas das implementações sugeridas aqui causarão repetidas avaliações dos operandos em alguns casos, o que pode levar a efeitos colaterais indesejados e, portanto, deve ser evitado.
Dito isto, uma xor
implementação que retorna uma True
ou False
é bastante simples; aquele que retorna um dos operandos, se possível, é muito mais complicado, porque não existe consenso sobre qual operando deve ser o escolhido, especialmente quando há mais de dois operandos. Por exemplo, deve xor(None, -1, [], True)
retornar None
, []
ouFalse
? Aposto que cada resposta aparece para algumas pessoas como a mais intuitiva.
Para o resultado Verdadeiro ou Falso, existem até cinco opções possíveis: retornar primeiro operando (se corresponder ao resultado final em valor, senão booleano), retornar primeiro resultado (se houver pelo menos um, senão booleano), return last operand (if ... else ...), return last match (if ... else ...), ou sempre retorne booleano. No total, são 5 ** 2 = 25 sabores de 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()