Wie erhält man das logische xor von zwei Variablen in Python?

Wie erhält man das logische xor von zwei Variablen in Python?

Zum Beispiel habe ich zwei Variablen, von denen ich erwarte, dass sie Zeichenfolgen sind. Ich möchte testen, ob nur einer von ihnen einen True-Wert enthält (nicht None oder die leere Zeichenfolge):

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

Der ^Operator scheint bitweise zu sein und nicht für alle Objekte definiert zu sein:

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

Wenn Sie die Eingaben bereits auf Boolesche Werte normalisieren, ist! = Xor.

bool(a) != bool(b)

Sie können immer die Definition von xor verwenden, um sie aus anderen logischen Operationen zu berechnen:

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

Aber das ist mir etwas zu ausführlich und auf den ersten Blick nicht besonders klar. Ein anderer Weg, dies zu tun, ist:

bool(a) ^ bool(b)

Der xor-Operator für zwei Boolesche Werte ist logisch xor (im Gegensatz zu Ints, wo er bitweise ist). Was Sinn macht, da booles sich nur um eine Unterklasse von handeltint , aber implementiert wird, um nur die Werte 0und zu haben 1. Und logisches xor entspricht bitweisem xor, wenn die Domäne auf 0und beschränkt ist 1.

Die logical_xorFunktion würde also wie folgt implementiert:

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

Dank an Nick Coghlan auf der Python-3000-Mailingliste .

Bitweise exklusiv - oder ist bereits in Python im operatorModul integriert (identisch mit dem ^Operator):

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

Wie Zach erklärte, können Sie verwenden:

xor = bool(a) ^ bool(b)

Ich persönlich bevorzuge einen etwas anderen Dialekt:

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

Dieser Dialekt ist inspiriert von einer logischen Diagrammsprache, die ich in der Schule gelernt habe, in der "ODER" durch ein Kästchen mit ≥1(größer oder gleich 1) und "XOR" durch ein Kästchen mit =1.

Dies hat den Vorteil, dass exklusive oder mehrere Operanden korrekt implementiert werden.

• "1 = a ^ b ^ c ..." bedeutet, dass die Anzahl der wahren Operanden ungerade ist. Dieser Operator ist "Parität".
• "1 = a + b + c ..." bedeutet, dass genau ein Operand wahr ist. Dies ist "exklusiv oder" und bedeutet "eins unter Ausschluss der anderen".

• Python logisch or: A or B: Erträge , Awenn bool(A)ist True, sonst kehrtB
• Python logisch and: A and B: Erträge , Awenn bool(A)ist False, sonst kehrtB

Um den größten Teil dieser Denkweise beizubehalten, wäre meine logische xor Definition:

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

Auf diese Weise können sie zurückkehren a, boder False:

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

Ich habe verschiedene Ansätze getestet und not a != (not b) schien der schnellste zu sein.

Hier sind einige Tests

%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

Bearbeiten: In den obigen Beispielen 1 und 3 fehlen Klammern, sodass das Ergebnis falsch ist. Neue Ergebnisse + truth()Funktion wie von ShadowRanger vorgeschlagen.

%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

Belohnungsthread:

Anoder Idee ... Versuchen Sie einfach den (möglicherweise) pythonischen Ausdruck «ist nicht», um das Verhalten des logischen «xor» zu erhalten.

Die Wahrheitstabelle wäre:

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

Und für Ihre Beispielzeichenfolge:

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

Jedoch; Wie oben angegeben, hängt es vom tatsächlichen Verhalten ab, das Sie bei einigen Saiten herausziehen möchten, da Saiten keine Boleans sind ... und noch mehr: Wenn Sie in Python eintauchen, finden Sie "The Peculiar Nature of". und "und" oder "» http://www.diveintopython.net/power_of_introspection/and_or.html

Entschuldigung, mein geschriebenes Englisch, es ist nicht meine geborene Sprache.

Grüße.

Python hat einen bitweisen Exklusiv-ODER-Operator ^:

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

Sie können es verwenden, indem Sie die Eingaben in Boolesche Werte konvertieren, bevor Sie xor ( ^) anwenden :

bool(a) ^ bool(b)

(Bearbeitet - danke Arel)

Da ich die einfache Variante von xor nicht sehe, die variable Argumente verwendet und nur die Wahrheitswerte True oder False verwendet, werde ich sie hier nur für jedermann verwenden. Es ist, wie von anderen bemerkt, hübsch (um nicht sehr zu sagen) unkompliziert.

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

Auch die Verwendung ist unkompliziert:

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

Da dies das verallgemeinerte n-ary logische XOR ist, ist sein Wahrheitswert immer dann True, wenn die Anzahl der True-Operanden ungerade ist (und nicht nur, wenn genau einer True ist, dies ist nur ein Fall, in dem n-ary XOR True ist).

Wenn Sie also nach einem n-ary-Prädikat suchen, das nur dann True ist, wenn genau einer seiner Operanden ist, möchten Sie möglicherweise Folgendes verwenden:

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

Exklusiv Oder ist wie folgt definiert

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

Manchmal arbeite ich mit 1 und 0 anstelle von booleschen True- und False-Werten. In diesem Fall kann xor definiert werden als

z = (x + y) % 2

welches die folgende Wahrheitstabelle hat:

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

Ich weiß, dass dies spät ist, aber ich hatte einen Gedanken und es könnte sich lohnen, nur zur Dokumentation. Vielleicht würde das funktionieren: np.abs(x-y)Die Idee ist das

1. Wenn x = True = 1 und y = False = 0, wäre das Ergebnis | 1-0 | = 1 = True
2. Wenn x = False = 0 und y = False = 0, wäre das Ergebnis | 0-0 | = 0 = False
3. Wenn x = True = 1 und y = True = 1, wäre das Ergebnis | 1-1 | = 0 = False
4. Wenn x = False = 0 und y = True = 1, wäre das Ergebnis | 0-1 | = 1 = True

Einfach, leicht zu verstehen:

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

Wenn Sie nach einer exklusiven Auswahl suchen, kann diese auf mehrere Argumente erweitert werden:

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

Wie wäre es damit?

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

wird geben, awenn bfalsch ist,
wird geben, bwenn afalsch ist,
wird gebenFalse anders

Oder mit dem ternären Ausdruck Python 2.5+:

(False if a else b) if b else a

Einige der hier vorgeschlagenen Implementierungen führen in einigen Fällen zu einer wiederholten Bewertung der Operanden, was zu unbeabsichtigten Nebenwirkungen führen kann und daher vermieden werden muss.

Das heißt, eine xorImplementierung, die entweder zurückgibt Trueoder Falseziemlich einfach ist; Eine, die nach Möglichkeit einen der Operanden zurückgibt, ist viel schwieriger, da kein Konsens darüber besteht, welcher Operand der ausgewählte sein soll, insbesondere wenn mehr als zwei Operanden vorhanden sind. Zum Beispiel sollte xor(None, -1, [], True)zurückkehren None, []oderFalse ? Ich wette, jede Antwort erscheint einigen Leuten als die intuitivste.

Für das True- oder das False-Ergebnis gibt es bis zu fünf mögliche Optionen: Rückgabe des ersten Operanden (wenn er mit dem Endergebnis im Wert übereinstimmt, sonst Boolescher Wert), Rückgabe der ersten Übereinstimmung (wenn mindestens einer vorhanden ist, sonst Boolescher Wert), letzten Operanden zurückgeben (wenn ... sonst ...), letzte Übereinstimmung zurückgeben (wenn ... sonst ...) oder immer boolesch zurückgeben. Insgesamt sind das 5 ** 2 = 25 Geschmacksrichtungen 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()

Viele Leute, einschließlich mir, benötigen eine xorFunktion, die sich wie eine xor-Schaltung mit n Eingängen verhält, wobei n variabel ist. (Siehe https://en.wikipedia.org/wiki/XOR_gate ). Die folgende einfache Funktion implementiert dies.

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)

Beispiel-E / A folgt:

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

So erhalten Sie das logische xor von zwei oder mehr Variablen in Python:

1. Konvertieren Sie Eingaben in Boolesche Werte
2. Verwenden Sie den bitweisen xor-Operator ( ^oder operator.xor)

Zum Beispiel,

bool(a) ^ bool(b)

Wenn Sie die Eingaben in Boolesche Werte konvertieren, wird bitweises xor zu logischem xor.

Beachten Sie, dass die akzeptierte Antwort falsch ist: Sie != ist aufgrund der Subtilität der Operatorverkettung nicht mit xor in Python identisch .

Zum Beispiel ist das xor der drei folgenden Werte falsch, wenn !=:

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

(PS Ich habe versucht, die akzeptierte Antwort so zu bearbeiten, dass sie diese Warnung enthält, aber meine Änderung wurde abgelehnt.)

Es ist einfach, wenn Sie wissen, was XOR tut:

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

Dies erhält das logische exklusive XOR für zwei (oder mehr) Variablen

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

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

Das erste Problem bei diesem Setup besteht darin, dass es höchstwahrscheinlich die gesamte Liste zweimal durchläuft und mindestens eines der Elemente mindestens zweimal überprüft. Dies kann das Codeverständnis verbessern, führt jedoch nicht zu einer Geschwindigkeitssteigerung (die sich je nach Anwendungsfall vernachlässigbar unterscheiden kann).

Das zweite Problem bei diesem Setup besteht darin, dass unabhängig von der Anzahl der Variablen die Exklusivität überprüft wird. Dies kann zunächst als Merkmal angesehen werden, aber das erste Problem wird mit zunehmender Anzahl von Variablen (falls dies jemals der Fall ist) viel bedeutender.

Xor ist ^in Python. Es gibt zurück:

• Ein bitweises xor für Ints
• Logisches xor für Bools
• Eine exklusive Vereinigung für Sets
• Benutzerdefinierte Ergebnisse für implementierte Klassen __xor__.
• TypeError für undefinierte Typen wie Zeichenfolgen oder Wörterbücher.

Wenn Sie sie ohnehin für Zeichenfolgen verwenden möchten, boolwird Ihre Operation durch Eingießen eindeutig (Sie könnten auch meinen set(str1) ^ set(str2)).

XOR ist implementiert in operator.xor.

So würde ich jede Wahrheitstabelle codieren. Insbesondere für xor haben wir:

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

Schauen Sie sich einfach die T-Werte in der Antwortspalte an und setzen Sie alle wahren Fälle mit logischem oder zusammen. Diese Wahrheitstabelle kann also in Fall 2 oder 3 erstellt werden.

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

Wir können xor von zwei Variablen leicht finden, indem wir verwenden:

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

Beispiel:

xor (Richtig, Falsch) >>> Richtig