Come si ottiene lo xor logico di due variabili in Python?

Come si ottiene lo xor logico di due variabili in Python?

Ad esempio, ho due variabili che mi aspetto siano stringhe. Voglio provare che solo uno di essi contiene un valore True (non è None o la stringa vuota):

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

L' ^operatore sembra essere bit a bit e non definito su tutti gli oggetti:

>>> 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 stai già normalizzando gli input in booleani, allora! = È xor.

bool(a) != bool(b)

Puoi sempre usare la definizione di xor per calcolarlo da altre operazioni logiche:

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

Ma questo è un po 'troppo prolisso per me e non è particolarmente chiaro a prima vista. Un altro modo per farlo è:

bool(a) ^ bool(b)

L'operatore xor su due booleani è xor logico (a differenza di ints, dove è bit a bit). Il che ha senso, poiché boolè solo una sottoclasse diint , ma è implementato per avere solo i valori 0e 1. E xor logico equivale a xor bit a bit quando il dominio è limitato a 0e 1.

Quindi la logical_xorfunzione sarebbe implementata come:

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

Ringraziamo Nick Coghlan nella mailing list di Python-3000 .

Bitwise esclusivo o è già integrato in Python, nel operatormodulo (che è identico ^all'operatore):

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

Come ha spiegato Zach , puoi usare:

xor = bool(a) ^ bool(b)

Personalmente, preferisco un dialetto leggermente diverso:

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

Questo dialetto è ispirato da un linguaggio logico di diagrammi che ho imparato a scuola in cui "OR" era indicato da una casella contenente ≥1(maggiore o uguale a 1) e "XOR" era indicato da una casella contenente =1.

Ciò ha il vantaggio di implementare correttamente esclusivi o su più operandi.

• "1 = a ^ b ^ c ..." significa che il numero di operandi veri è dispari. Questo operatore è "parità".
• "1 = a + b + c ..." significa che esattamente un operando è vero. Questo è "esclusivo o", che significa "uno ad esclusione degli altri".

• Python logic or:: A or Brestituisce Aif bool(A)is True, altrimenti restituisceB
• Python logic and:: A and Brestituisce Aif bool(A)is False, altrimenti restituisceB

Per mantenere la maggior parte di quel modo di pensare, la mia logica definizione xor sarebbe:

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

In questo modo si può tornare a, bo False:

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

Ho testato diversi approcci e mi è not a != (not b)sembrato il più veloce.

Ecco alcuni test

%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

Modifica: gli esempi 1 e 3 sopra mancano le parentesi quindi il risultato non è corretto. Nuovi risultati + truth()funzione come suggerito da 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

Discussione gratificante:

Un'idea ancora ... Basta provare l'espressione pitonica (forse) «non è» per ottenere un comportamento «logico» o

La tabella della verità sarebbe:

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

E per la tua stringa di esempio:

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

Però; come indicato sopra, dipende dal comportamento effettivo che si desidera estrarre da qualsiasi coppia di stringhe, perché le stringhe non sono bolean ... e ancora di più: se si "Dive Into Python" troverai "The Peculiar Nature of" e "e" o "» http://www.diveintopython.net/power_of_introspection/and_or.html

Scusate il mio inglese scritto, non è la mia lingua nata.

Saluti.

Python ha un operatore OR bit a bit esclusivo, è ^:

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

Puoi usarlo convertendo gli input in booleani prima di applicare xor ( ^):

bool(a) ^ bool(b)

(Modificato - grazie Arel)

Dato che non vedo la semplice variante di xor che usa argomenti variabili e solo operazioni sui valori di Verità Vero o Falso, lo lancerò qui per essere usato da chiunque. È come notato da altri, piuttosto (per non dire molto) semplice.

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

E anche l'uso è semplice:

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

Dato che questo è lo XOR logico n-ary generalizzato, il suo valore di verità sarà True ogni volta che il numero di operandi True sarà dispari (e non solo quando esattamente uno è True, questo è solo un caso in cui X-nOR ary è True).

Quindi, se sei alla ricerca di un predicato n-ary che è True solo quando è esattamente uno dei suoi operandi, potresti voler usare:

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

Esclusivo O è definito come segue

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

A volte mi ritrovo a lavorare con 1 e 0 invece di valori booleani True e False. In questo caso xor può essere definito come

z = (x + y) % 2

che ha la seguente tabella di verità:

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

So che è tardi, ma ho pensato e potrebbe valere la pena, solo per la documentazione. Forse questo funzionerebbe: np.abs(x-y)l'idea è quella

1. se x = True = 1 e y = False = 0 il risultato sarebbe | 1-0 | = 1 = True
2. se x = False = 0 e y = False = 0 il risultato sarebbe | 0-0 | = 0 = Falso
3. se x = True = 1 e y = True = 1 il risultato sarebbe | 1-1 | = 0 = Falso
4. se x = False = 0 e y = True = 1 il risultato sarebbe | 0-1 | = 1 = True

Semplice, facile da capire:

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

Se una scelta esclusiva è ciò che stai cercando, può essere estesa a più argomenti:

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

Cosa ne pensi di questo?

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

darà ase bè falso
darà bse aè falso
darà Falsealtrimenti

O con l'espressione ternaria Python 2.5+:

(False if a else b) if b else a

Alcune delle implementazioni suggerite qui causeranno una valutazione ripetuta degli operandi in alcuni casi, il che può portare a effetti collaterali indesiderati e pertanto deve essere evitato.

Detto questo, xorun'implementazione che ritorna Trueo Falseè abbastanza semplice; uno che restituisce uno degli operandi, se possibile, è molto più complicato, perché non esiste alcun consenso su quale operando dovrebbe essere quello scelto, specialmente quando ci sono più di due operandi. Per esempio, dovrebbe xor(None, -1, [], True)tornare None, []oFalse ? Scommetto che ogni risposta appare ad alcune persone come la più intuitiva.

Per il risultato Vero o Falso, ci sono fino a cinque possibili scelte: restituisce il primo operando (se corrisponde al risultato finale in valore, altrimenti booleano), restituisce la prima corrispondenza (se ne esiste almeno una, altrimenti booleana), restituisce l'ultimo operando (if ... else ...), restituisce l'ultima corrispondenza (if ... else ...) o restituisce sempre booleano. Complessivamente, questo è 5 ** 2 = 25 gusti di 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()

Molte persone, incluso me stesso, hanno bisogno di una xorfunzione che si comporti come un circuito x-input n, in cui n è variabile. (Vedi https://en.wikipedia.org/wiki/XOR_gate ). La seguente semplice funzione implementa questo.

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)

Segue I / O di esempio:

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

Per ottenere lo xor logico di due o più variabili in Python:

1. Converti input in valori booleani
2. Utilizzare l'operatore xor bit a bit ( ^o operator.xor)

Per esempio,

bool(a) ^ bool(b)

Quando si convertono gli input in booleani, xor bit a bit diventa xor logico .

Nota che la risposta accettata è sbagliata: != non è la stessa di xor in Python a causa della sottigliezza del concatenamento dell'operatore .

Ad esempio, lo xor dei tre valori seguenti è errato quando si utilizza !=:

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

(PS Ho provato a modificare la risposta accettata per includere questo avviso, ma la mia modifica è stata respinta.)

È facile quando sai cosa fa 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))

Ciò ottiene l'XOR logico esclusivo per due (o più) variabili

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

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

Il primo problema con questa configurazione è che molto probabilmente attraversa l'intero elenco due volte e, come minimo, controllerà almeno uno degli elementi due volte. Quindi può aumentare la comprensione del codice, ma non si presta alla velocità (che può differire in modo trascurabile a seconda del caso d'uso).

Il secondo problema con questa configurazione è che controlla l'esclusività indipendentemente dal numero di variabili. Questo può essere inizialmente considerato una caratteristica, ma il primo problema diventa molto più significativo con l'aumentare del numero di variabili (se mai lo fanno).

Xor è ^in Python. Restituisce:

• Un xor bit a bit per ints
• Logico xor per bool
• Un'unione esclusiva per i set
• Risultati definiti dall'utente per le classi che implementano __xor__ .
• TypeError per tipi non definiti, come stringhe o dizionari.

Se hai intenzione di usarli sulle stringhe comunque, inserirle boolrende l'operazione inequivocabile (potresti anche voler dire set(str1) ^ set(str2)).

XOR è implementato in operator.xor.

Ecco come codificarei qualsiasi tabella di verità. Per xor in particolare abbiamo:

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

Basta guardare i valori T nella colonna delle risposte e mettere insieme tutti i casi veri con logico o. Quindi, questa tabella di verità può essere prodotta nel caso 2 o 3. Quindi,

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

Possiamo facilmente trovare xor di due variabili usando:

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

Esempio:

xor (Vero, Falso) >>> Vero