Wie erhält man das logische Xor zweier Variablen in Python?

Question

Wie erhalten Sie die logisches Xor von zwei Variablen in Python?

Ich habe zum Beispiel zwei Variablen, von denen ich erwarte, dass sie Zeichenketten sind. Ich möchte testen, ob nur eine von ihnen einen wahren Wert enthält (also nicht None oder die leere Zeichenkette ist):

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

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

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

Answer 1

Da ich nicht sehe, die einfache Variante von xor mit variablen Argumenten und nur Betrieb auf Truth Werte True oder False, ich werde nur werfen es hier für jedermann zu verwenden. Es ist, wie bereits von anderen erwähnt, ziemlich (um nicht zu sagen sehr) einfach.

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

Und auch die Nutzung ist unkompliziert:

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

Da es sich hierbei um das verallgemeinerte n-äre logische XOR handelt, ist sein Wahrheitswert immer dann wahr, wenn die Anzahl der wahren Operanden ungerade ist (und nicht nur, wenn genau einer wahr ist; dies ist nur ein Fall, in dem das n-äre XOR wahr ist).

Wenn Sie also auf der Suche nach einem n-ären Prädikat sind, das nur dann wahr ist, wenn genau einer seiner Operanden wahr ist, können Sie es verwenden:

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

Answer 2

Sie verwenden denselben XOR-Operator wie in C, der lautet ^ .

Ich weiß nicht, warum, aber die am meisten hochgestimmte Lösung schlägt vor bool(A) != bool(B) während ich - in Übereinstimmung mit C's Worten - sagen würde ^ ist die naheliegendste Lösung:

bool(A) ^ bool(B)

die besser lesbar und sofort verständlich ist für jeden, der von C oder jede C -abgeleitete Sprache ...

beim Code-Golfen, wahrscheinlich

not A ^ (not B)

wird der Gewinner sein. mit not als Konverter für boolean (ein Buchstabe weniger als bool() . Und für den ersten Ausdruck kann man in manchen Fällen die Paranthesen weglassen. Nun, es kommt darauf an, in Fällen, in denen man Folgendes tun muss not(A) ^ (not(B)) El bool() braucht die gleiche Anzahl von Buchstaben ...

Answer 3

Belohnender Faden:

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

Die Wahrheitstabelle würde lauten:

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

Und für Ihren Beispielstring:

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

Wie auch immer; wie sie oben angedeutet haben, hängt es von dem tatsächlichen Verhalten ab, das Sie aus einem Paar Strings herausziehen wollen, denn Strings sind keine Boleans... und noch mehr: wenn Sie "Dive Into Python" finden Sie "The Peculiar Nature of "and" and "or""" http://www.diveintopython.net/power_of_introspection/and_or.html

Entschuldigen Sie mein schlecht geschriebenes Englisch, es ist nicht meine Muttersprache.

Herzliche Grüße.

Answer 4

Viele Leute, mich eingeschlossen, brauchen eine xor Funktion, die sich wie eine xor-Schaltung mit n Eingängen verhält, wobei n eine Variable 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)

Es folgt ein Beispiel für E/A:

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

Answer 5

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

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