¿Cómo se obtiene el xor lógico de dos variables en Python?

¿Cómo se obtiene el xor lógico? de dos variables en Python?

Por ejemplo, tengo dos variables que espero sean cadenas. Quiero probar que solo uno de ellos contiene un valor Verdadero (no es Ninguno o la cadena vacía):

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

El ^operador parece ser bit a bit y no está definido en todos los 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'

Si ya está normalizando las entradas a booleanos, entonces! = Es xor.

bool(a) != bool(b)

Siempre puede usar la definición de xor para calcularla a partir de otras operaciones lógicas:

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

Pero esto es demasiado detallado para mí, y no es particularmente claro a primera vista. Otra forma de hacerlo es:

bool(a) ^ bool(b)

El operador xor en dos booleanos es xor lógico (a diferencia de los ints, donde es bit a bit). Lo cual tiene sentido, ya que booles solo una subclase deint , pero se implementa para tener solo los valores 0y 1. Y xor lógico es equivalente a xor bit a bit cuando el dominio está restringido a 0y1 .

Entonces la logical_xorfunción se implementaría como:

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

Crédito a Nick Coghlan en la lista de correo Python-3000 .

Bitwise exclusive-or ya está integrado en Python, en el operatormódulo (que es idéntico al ^operador):

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

Como explicó Zach , puedes usar:

xor = bool(a) ^ bool(b)

Personalmente, estoy a favor de un dialecto ligeramente diferente:

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

Este dialecto está inspirado en un lenguaje de diagramación lógico que aprendí en la escuela, donde "OR" se denota con un cuadro que contiene ≥1(mayor o igual que 1) y "XOR" se denota con un cuadro que contiene=1 .

Esto tiene la ventaja de implementar correctamente operandos exclusivos o múltiples.

• "1 = a ^ b ^ c ..." significa que el número de operandos verdaderos es impar. Este operador es "paridad".
• "1 = a + b + c ..." significa que exactamente un operando es verdadero. Esto es "exclusivo o", que significa "uno para la exclusión de los demás".

• Python lógico or:: A or Bdevuelve Asi bool(A)esTrue , de lo contrario devuelveB
• Python lógico and:: A and Bdevuelve Asi bool(A)esFalse , de lo contrario devuelveB

Para mantener la mayor parte de esa forma de pensar, mi definición lógica o xor sería:

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

De esa manera se puede devolver a, bo False:

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

He probado varios enfoques y not a != (not b)parecía ser el más rápido.

Aquí hay algunas pruebas

%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

Editar: los ejemplos 1 y 3 anteriores faltan paréntesis, por lo que el resultado es incorrecto. Nuevos resultados + truth()función como sugirió 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

Hilo gratificante:

Una idea más antigua ... Solo intente la (puede ser) expresión pitónica «no es» para obtener un comportamiento de «xor» lógico

La tabla de verdad sería:

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

Y para su cadena de ejemplo:

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

Sin embargo; como indicaron anteriormente, depende del comportamiento real que desee extraer de cualquier par de cuerdas, porque las cuerdas no son boletines ... y aún más: si se «sumerge en Python» encontrará «La naturaleza peculiar de" y "y" o "» http://www.diveintopython.net/power_of_introspection/and_or.html

Lo siento, mi inglés escrito, no es mi lengua materna.

Saludos.

Python tiene un operador OR exclusivo bit a bit, es ^:

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

Puede usarlo convirtiendo las entradas a booleanos antes de aplicar xor ( ^):

bool(a) ^ bool(b)

(Editado - gracias Arel)

Como no veo la variante simple de xor usando argumentos variables y solo operando con valores de Verdad Verdadero o Falso, lo lanzaré aquí para que cualquiera lo use. Es como lo han señalado otros, bastante (por no decir muy) directo.

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

Y el uso también es sencillo:

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

Como este es el XOR lógico n-ario generalizado, su valor de verdad será verdadero siempre que el número de operandos verdaderos sea impar (y no solo cuando exactamente uno es verdadero, este es solo un caso en el que XOR n-ario es verdadero).

Por lo tanto, si está buscando un predicado n-ario que solo sea verdadero cuando exactamente uno de sus operandos lo es, es posible que desee usar:

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

Exclusivo O se define de la siguiente manera

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

A veces me encuentro trabajando con 1 y 0 en lugar de valores booleanos True y False. En este caso, xor se puede definir como

z = (x + y) % 2

que tiene la siguiente tabla de verdad:

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

Sé que es tarde, pero pensé y podría valer la pena, solo por documentación. Quizás esto funcionaría: np.abs(x-y)la idea es que

1. si x = Verdadero = 1 e y = Falso = 0, entonces el resultado sería | 1-0 | = 1 = Verdadero
2. si x = False = 0 ey = False = 0, entonces el resultado sería | 0-0 | = 0 = False
3. si x = Verdadero = 1 ey = Verdadero = 1, entonces el resultado sería | 1-1 | = 0 = Falso
4. si x = False = 0 e y = True = 1, entonces el resultado sería | 0-1 | = 1 = True

Simple, fácil de entender:

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

Si lo que busca es una opción exclusiva, puede expandirse a múltiples argumentos:

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

¿Qué tal esto?

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

dará asi bes falso
dará bsi aes falso
daráFalse contrario

O con la expresión ternaria Python 2.5+:

(False if a else b) if b else a

Algunas de las implementaciones sugeridas aquí causarán una evaluación repetida de los operandos en algunos casos, lo que puede provocar efectos secundarios no deseados y, por lo tanto, debe evitarse.

Dicho esto, una xorimplementación que devuelve Trueo Falsees bastante simple; uno que devuelve uno de los operandos, si es posible, es mucho más complicado, porque no existe consenso sobre qué operando debe ser el elegido, especialmente cuando hay más de dos operandos. Por ejemplo, debería xor(None, -1, [], True)regresar None, []oFalse ? Apuesto a que cada respuesta parece ser la más intuitiva para algunas personas.

Para el resultado Verdadero o Falso, hay hasta cinco opciones posibles: devolver el primer operando (si coincide con el resultado final en valor, de lo contrario booleano), devolver la primera coincidencia (si existe al menos uno, de lo contrario booleano), devolver el último operando (si ... más ...), devolver la última coincidencia (si ... más ...), o siempre devolver boolean. En total, eso es 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()

Mucha gente, incluido yo mismo, necesita una xorfunción que se comporte como un circuito xor de entrada n, donde n es variable. (Ver https://en.wikipedia.org/wiki/XOR_gate ). La siguiente función simple implementa esto.

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)

Muestra de E / S a continuación:

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 obtener el xor lógico de dos o más variables en Python:

1. Convertir entradas a booleanos
2. Use el operador xor bit a bit ( ^o operator.xor)

Por ejemplo,

bool(a) ^ bool(b)

Cuando convierte las entradas a booleanos, xor bit a bit se convierte en xor lógico .

Tenga en cuenta que la respuesta aceptada es incorrecta: != no es lo mismo que xor en Python debido a la sutileza del encadenamiento del operador .

Por ejemplo, el xor de los tres valores siguientes es incorrecto cuando se usa !=:

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

(PD: intenté editar la respuesta aceptada para incluir esta advertencia, pero mi cambio fue rechazado).

Es fácil cuando sabes lo que hace 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))

Esto obtiene el XOR lógico exclusivo para dos (o más) variables

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

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

El primer problema con esta configuración es que lo más probable es que atraviese la lista completa dos veces y, como mínimo, verifique dos veces al menos uno de los elementos. Por lo tanto, puede aumentar la comprensión del código, pero no se presta a la velocidad (que puede diferir insignificantemente según su caso de uso).

El segundo problema con esta configuración es que verifica la exclusividad independientemente del número de variables. Al principio, esto puede considerarse como una característica, pero el primer problema se vuelve mucho más significativo a medida que aumenta el número de variables (si alguna vez lo hacen).

Xor está ^en Python. Vuelve :

• Un bit xor para ints
• Xor lógico para bools
• Una unión exclusiva para sets
• Resultados definidos por el usuario para las clases que implementa __xor__.
• TypeError para tipos indefinidos, como cadenas o diccionarios.

Si tiene la intención de usarlos en cadenas de todos modos, al transmitirlos, boolsu operación no es ambigua (también podría significar set(str1) ^ set(str2)).

XOR se implementa en operator.xor.

Así es como codificaría cualquier tabla de verdad. Para xor en particular tenemos:

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

Basta con mirar los valores T en la columna de respuesta y unir todos los casos verdaderos con lógico o. Entonces, esta tabla de verdad se puede producir en el caso 2 o 3. Por lo tanto,

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

Podemos encontrar fácilmente xor de dos variables usando:

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

Ejemplo:

xor (verdadero, falso) >>> verdadero