Como você obtém o xor lógico de duas variáveis ​​no Python?

Como você obtém o xor lógico de duas variáveis ​​no Python?

Por exemplo, eu tenho duas variáveis ​​que eu espero que sejam strings. Quero testar se apenas um deles contém um valor True (não é None ou a string vazia):

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

O ^operador parece estar bit a bit e não definido em todos os objetos:

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

Se você já está normalizando as entradas para booleanos, então! = É xor.

bool(a) != bool(b)

Você sempre pode usar a definição de xor para computá-la de outras operações lógicas:

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

Mas isso é um pouco detalhado demais para mim e não é particularmente claro à primeira vista. Outra maneira de fazer isso é:

bool(a) ^ bool(b)

O operador xor em dois booleanos é xor lógico (ao contrário de ints, onde é bit a bit). O que faz sentido, já que boolé apenas uma subclasse deint , mas é implementado para ter apenas os valores 0e 1. E xor lógico é equivalente a xor bit a bit quando o domínio está restrito a 0e 1.

Portanto, a logical_xorfunção seria implementada como:

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

Agradecemos a Nick Coghlan na lista de correspondência do Python-3000 .

Bitwise exclusivo - ou já está embutido no Python, no operatormódulo (que é idêntico ao ^operador):

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

Como Zach explicou, você pode usar:

xor = bool(a) ^ bool(b)

Pessoalmente, sou a favor de um dialeto ligeiramente diferente:

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

Esse dialeto é inspirado em uma linguagem de diagramação lógica que aprendi na escola, em que "OR" era indicado por uma caixa contendo ≥1(maior ou igual a 1) e "XOR" era indicado por uma caixa contendo =1.

Isso tem a vantagem de implementar corretamente operandos exclusivos ou em múltiplos.

• "1 = a ^ b ^ c ..." significa que o número de operandos verdadeiros é ímpar. Este operador é "paridade".
• "1 = a + b + c ..." significa que exatamente um operando é verdadeiro. Isso é "exclusivo ou", significando "um com exclusão dos outros".

• Python logic or:: A or Bretorna Ase bool(A)for True, caso contrário, retornaB
• Python logic and:: A and Bretorna Ase bool(A)for False, caso contrário, retornaB

Para manter a maior parte desse modo de pensar, minha definição lógica de xor seria:

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

Dessa forma, ele pode retornar a, bou False:

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

Eu testei várias abordagens e not a != (not b)parecia ser o mais rápido.

Aqui estão alguns testes

%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

Edit: Os exemplos 1 e 3 acima estão faltando parênteses, portanto o resultado está incorreto. Novos resultados + truth()funcionam como sugerido pelo 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

Segmento de recompensa:

Idéia de ânodo ... Basta tentar a expressão pitônica (pode ser) «não é» para obter o comportamento lógico «xor»

A tabela verdade seria:

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

E para o seu exemplo de string:

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

Contudo; como indicado acima, depende do comportamento real que você deseja obter sobre algumas cordas, porque cordas não são boleanas ... e ainda mais: se você «Dive Into Python», encontrará «The Peculiar Nature of" e "and" ou "» http://www.diveintopython.net/power_of_introspection/and_or.html

Desculpe meu inglês escrito, não é minha língua nativa.

Saudações.

Python tem um operador OR exclusivo bit a bit, é ^:

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

Você pode usá-lo convertendo as entradas em booleanos antes de aplicar xor ( ^):

bool(a) ^ bool(b)

(Editado - obrigado Arel)

Como não vejo a variante simples do xor usando argumentos variáveis ​​e apenas a operação nos valores de Verdadeiro Verdadeiro ou Falso, vou jogá-lo aqui para qualquer um usar. É como observado por outros, bastante (para não dizer muito) direto.

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

E o uso também é direto:

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

Como esse é o XOR lógico n-ário generalizado, seu valor de verdade será True sempre que o número de operandos True for ímpar (e não apenas quando exatamente um for True, este é apenas um caso em que o XOR n-ário é True).

Portanto, se você estiver em busca de um predicado n-ário que seja apenas True quando exatamente um de seus operandos for, convém usar:

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

Exclusive Or é definido da seguinte forma

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

Às vezes me pego trabalhando com 1 e 0 em vez de valores booleanos True e False. Nesse caso, xor pode ser definido como

z = (x + y) % 2

que possui a seguinte tabela de verdade:

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

Sei que é tarde, mas pensei em algo que poderia valer a pena, apenas para documentação. Talvez isso funcione: np.abs(x-y)a idéia é que

1. se x = True = 1 e y = False = 0, o resultado será | 1-0 | = 1 = True
2. se x = Falso = 0 e y = Falso = 0, o resultado seria | 0-0 | = 0 = Falso
3. se x = Verdadeiro = 1 e y = Verdadeiro = 1, o resultado será | 1-1 | = 0 = Falso
4. se x = Falso = 0 e y = Verdadeiro = 1, o resultado será | 0-1 | = 1 = Verdadeiro

Simples, fácil de entender:

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

Se você deseja uma opção exclusiva, ela pode ser expandida para vários argumentos:

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

Que tal agora?

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

dará ase bfor falso
dará bse afor falso
daráFalse caso contrário

Ou com a expressão ternária do Python 2.5+:

(False if a else b) if b else a

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 xorimplementação que retorna uma Trueou 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()

Muitas pessoas, inclusive eu, precisam de uma xorfunção que se comporte como um circuito xor de entrada n, onde n é variável. (Consulte https://en.wikipedia.org/wiki/XOR_gate ). A seguinte função simples implementa isso.

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)

E / S de amostra a seguir:

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

Para obter o xor lógico de duas ou mais variáveis ​​no Python:

1. Converter entradas em booleanos
2. Use o operador bit a bit xor ( ^ou operator.xor)

Por exemplo,

bool(a) ^ bool(b)

Quando você converte as entradas em booleanos, xor bit a bit se torna xor lógico .

Observe que a resposta aceita está errada: != não é a mesma que xor no Python devido à sutileza do encadeamento do operador .

Por exemplo, o xor dos três valores abaixo está errado ao usar !=:

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

(PS: tentei editar a resposta aceita para incluir esse aviso, mas minha alteração foi rejeitada.)

É fácil quando você sabe o que o XOR faz:

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

Isso obtém o XOR exclusivo lógico para duas (ou mais) variáveis

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

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

O primeiro problema dessa configuração é que ela provavelmente percorre a lista inteira duas vezes e, no mínimo, verifica pelo menos um dos elementos duas vezes. Portanto, isso pode aumentar a compreensão do código, mas não leva à velocidade (que pode diferir de maneira insignificante dependendo do seu caso de uso).

O segundo problema com essa instalação é que ele verifica a exclusividade, independentemente do número de variáveis. Isso pode ser visto a princípio como um recurso, mas o primeiro problema se torna muito mais significativo à medida que o número de variáveis ​​aumenta (se é que o fazem).

Xor está ^em Python. Retorna:

• Um xor bit a bit para ints
• Xor lógico para bools
• Uma união exclusiva para conjuntos
• Resultados definidos pelo usuário para classes que implementam __xor__ .
• TypeError para tipos indefinidos, como seqüências de caracteres ou dicionários.

Se você pretende usá-los em cadeias de qualquer maneira, convertê-las em booltorna sua operação inequívoca (você também pode querer dizer set(str1) ^ set(str2)).

O XOR é implementado no operator.xor.

É assim que eu codificaria qualquer tabela de verdade. Para o xor em particular, temos:

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

Basta olhar para os valores T na coluna de resposta e juntar todos os casos verdadeiros com lógica ou. Portanto, essa tabela de verdade pode ser produzida nos casos 2 ou 3. Portanto,

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

Podemos encontrar facilmente xor de duas variáveis ​​usando:

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

Exemplo:

xor (Verdadeiro, Falso) >>> Verdadeiro