Jak uzyskać logiczny xor dwóch zmiennych w Pythonie?

Jak uzyskać logiczny xor dwóch zmiennych w Pythonie?

Na przykład mam dwie zmienne, które prawdopodobnie będą łańcuchami. Chcę przetestować, czy tylko jeden z nich zawiera wartość True (nie jest to None ani pusty ciąg znaków):

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

^Operator wydaje się być bitowe, a nie zdefiniowane na wszystkich obiektach:

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

Jeśli już normalizujesz dane wejściowe do wartości logicznych, to! = Jest xor.

bool(a) != bool(b)

Zawsze możesz użyć definicji xor, aby obliczyć ją na podstawie innych operacji logicznych:

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

Ale jest to dla mnie trochę zbyt szczegółowe i na pierwszy rzut oka nie jest szczególnie jasne. Innym sposobem na to jest:

bool(a) ^ bool(b)

Operator xor na dwóch boolach jest logicznym xor (w przeciwieństwie do ints, gdzie jest bitowy). To ma sens, ponieważ booljest tylko podklasąint , ale jest implementowane tak, aby zawierało tylko wartości 0i 1. Logiczny xor jest równoważny bitowemu xor, gdy domena jest ograniczona do 0i 1.

Tak więc logical_xorfunkcja zostanie zaimplementowana w następujący sposób:

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

Podziękowania dla Nicka Coghlana z listy mailingowej Python-3000 .

Bitowe wykluczanie - lub jest już wbudowane w Pythona, w operatormodule (który jest identyczny z ^operatorem):

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

Jak wyjaśnił Zach , możesz użyć:

xor = bool(a) ^ bool(b)

Osobiście preferuję nieco inny dialekt:

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

Ten dialekt jest zainspirowany logicznym językiem diagramów, którego nauczyłem się w szkole, gdzie „OR” oznaczono ramką zawierającą ≥1(większą lub równą 1), a „XOR” oznaczono ramką zawierającą =1.

Ma to tę zaletę, że poprawnie implementuje wyłączne lub na wielu operandach.

• „1 = a ^ b ^ c ...” oznacza, że ​​liczba prawdziwych operandów jest nieparzysta. Ten operator to „parzystość”.
• „1 = a + b + c ...” oznacza, że ​​dokładnie jeden operand jest prawdziwy. Jest to „wyłączne lub”, co oznacza „jedno z wyłączeniem pozostałych”.

• Python logical or:: A or Bzwraca Ajeśli bool(A)jest True, w przeciwnym razie zwracaB
• Python logical and:: A and Bzwraca Ajeśli bool(A)jest False, w przeciwnym razie zwracaB

Aby zachować większość tego sposobu myślenia, moją logiczną definicją xor byłoby:

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

W ten sposób może powrócić a, balbo False:

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

Przetestowałem kilka podejść i not a != (not b)okazało się, że jest najszybszy.

Oto kilka testów

%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

Edycja: W przykładach 1 i 3 powyżej brakuje nawiasów, więc wynik jest niepoprawny. Nowe wyniki + truth()funkcja, jak sugerował 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

Nagradzany wątek:

Pomysł anodera ... Wystarczy wypróbować (być może) pythonowe wyrażenie «nie», aby uzyskać zachowanie logicznego «xor»

Tabela prawdy wyglądałaby następująco:

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

A na przykład ciąg:

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

Jednak; jak wskazano powyżej, zależy to od faktycznego zachowania, które chcesz wyciągnąć z dowolnej pary ciągów, ponieważ ciągi nie są boleanami ... a nawet więcej: jeśli „Zanurzysz się w Pythonie”, znajdziesz „Osobliwą naturę” oraz „i” lub „» http://www.diveintopython.net/power_of_introspection/and_or.html

Przepraszam, mój napisany angielski, to nie jest mój urodzony język.

Pozdrowienia.

Python ma bitowo wyłączny operator OR, to ^:

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

Możesz go użyć, konwertując dane wejściowe na booleany przed zastosowaniem xor ( ^):

bool(a) ^ bool(b)

(Edytowane - dzięki Arel)

Ponieważ nie widzę prostego wariantu xor wykorzystującego zmienne argumenty i tylko operację na wartościach Prawdy Prawda lub Fałsz, po prostu wyrzucę go tutaj, aby każdy mógł z niego skorzystać. Jest to, jak zauważają inni, dość (by nie powiedzieć bardzo) proste.

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

Użycie jest również proste:

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

Ponieważ jest to uogólniony n-ary logiczny XOR, jego wartość prawdy będzie Prawda za każdym razem, gdy liczba argumentów True będzie nieparzysta (i nie tylko wtedy, gdy dokładnie jeden jest Prawdą, to tylko jeden przypadek, w którym n-ary XOR jest Prawdą).

Dlatego jeśli szukasz predykatu n-ary, który ma wartość Prawda tylko wtedy, gdy jest dokładnie jeden z jego argumentów, możesz użyć:

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

Wyłączne lub jest zdefiniowane w następujący sposób

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

Czasami pracuję z 1 i 0 zamiast boolowskich wartości True i False. W tym przypadku xor można zdefiniować jako

z = (x + y) % 2

który ma następującą tabelę prawdy:

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

Wiem, że jest późno, ale pomyślałem i może warto, tylko dla dokumentacji. Być może to zadziała: np.abs(x-y)pomysł jest taki

1. jeśli x = prawda = 1, ay = fałsz = 0, to wynikiem będzie | 1-0 | = 1 = prawda
2. jeśli x = False = 0, ay = False = 0, wynikiem będzie | 0-0 | = 0 = False
3. jeśli x = prawda = 1, ay = prawda = 1, wówczas wynikiem będzie | 1-1 | = 0 = fałsz
4. jeśli x = False = 0, ay = True = 1, wynikiem będzie | 0-1 | = 1 = True

Prosty, łatwy do zrozumienia:

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

Jeśli szukasz ekskluzywnego wyboru, możesz go rozszerzyć na wiele argumentów:

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

Co powiesz na to?

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

da, ajeśli bjest fałsz
, da, bjeśli ajest fałsz
, da Falseinaczej

Lub z wyrażeniem potrójnym Python 2.5+:

(False if a else b) if b else a

Niektóre sugerowane tutaj implementacje spowodują w niektórych przypadkach ponowną ocenę operandów, co może prowadzić do niezamierzonych efektów ubocznych i dlatego należy ich unikać.

Powiedział, że xorrealizacja który powraca albo Trueczy Falsejest dość prosta; jeden, który zwraca jeden z operandów, jeśli to możliwe, jest znacznie trudniejszy, ponieważ nie istnieje konsensus co do tego, który operand powinien być wybrany, zwłaszcza gdy są więcej niż dwa operandy. Na przykład, należy xor(None, -1, [], True)powrócić None, []albo False? Założę się, że każda odpowiedź wydaje się niektórym osobom najbardziej intuicyjna.

W przypadku wyniku True lub False istnieje aż pięć możliwych opcji: zwróć pierwszy operand (jeśli jest zgodny, wynikiem końcowym jest wartość, w przeciwnym razie boolean), zwróć pierwsze dopasowanie (jeśli przynajmniej jeden istnieje, boolean), zwraca ostatni argument (jeśli ... else ...), zwraca ostatni mecz (jeśli ... else ...) lub zawsze zwraca wartość logiczną. W sumie to 5 ** 2 = 25 smaków 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()

Wielu ludzi, w tym ja, potrzebuje xorfunkcji, która zachowuje się jak obwód xor wejściowy n, gdzie n jest zmienne. (Zobacz https://en.wikipedia.org/wiki/XOR_gate ). Implementuje to następująca prosta funkcja.

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)

Przykładowe I / O:

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

Aby uzyskać logiczny xor dwóch lub więcej zmiennych w Pythonie:

1. Konwertuj dane wejściowe na logiczne
2. Użyj bitowego operatora xor ( ^lub operator.xor)

Na przykład,

bool(a) ^ bool(b)

Podczas konwersji danych wejściowych na logiczne, bitowe xor staje się logicznym xor.

Zauważ, że zaakceptowana odpowiedź jest niepoprawna: != nie jest taka sama jak xor w Pythonie z powodu subtelności łączenia operatorów .

Na przykład xor trzech poniższych wartości jest niepoprawny podczas używania !=:

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

(PS Próbowałem edytować zaakceptowaną odpowiedź, aby uwzględnić to ostrzeżenie, ale moja zmiana została odrzucona).

Łatwo jest, gdy wiesz, co robi 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))

Otrzymuje to logiczne wyłączne XOR dla dwóch (lub więcej) zmiennych

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

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

Pierwszym problemem związanym z tą konfiguracją jest to, że najprawdopodobniej przeszukuje całą listę dwa razy i przynajmniej sprawdzi co najmniej jeden z elementów dwa razy. Może to zwiększyć zrozumienie kodu, ale nie przyspiesza (co może nieznacznie różnić się w zależności od przypadku użycia).

Drugi problem z tym ustawieniem polega na tym, że sprawdza wyłączność niezależnie od liczby zmiennych. Z początku można to uznać za cechę, ale pierwszy problem staje się o wiele bardziej znaczący wraz ze wzrostem liczby zmiennych (jeśli kiedykolwiek tak się dzieje).

Xor jest ^w Pythonie. Zwraca:

• Bitowe xor dla ints
• Logiczne xor dla booli
• Ekskluzywny związek dla zestawów
• Zdefiniowane przez użytkownika wyniki dla klas, które implementują __xor__.
• Błąd typu dla niezdefiniowanych typów, takich jak ciągi znaków lub słowniki.

Jeśli i tak zamierzasz używać ich na ciągach, rzutowanie ich boolsprawia, że ​​twoja operacja jest jednoznaczna (możesz także powiedzieć set(str1) ^ set(str2)).

XOR jest zaimplementowany w operator.xor.

W ten sposób kodowałbym każdą tabelę prawdy. W szczególności dla XOR mamy:

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

Wystarczy spojrzeć na wartości T w kolumnie odpowiedzi i połączyć razem wszystkie prawdziwe przypadki za pomocą logicznego lub. Tak więc ta tabela prawdy może zostać stworzona w przypadku 2 lub 3. Stąd,

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

Możemy łatwo znaleźć xor dwóch zmiennych, używając:

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

Przykład:

xor (prawda, fałsz) >>> prawda