Як ви отримуєте логічний xor двох змінних у Python?

Як ви отримуєте логічний xor двох змінних у Python?

Наприклад, у мене є дві змінні, які, як я очікую, будуть рядками. Я хочу перевірити, що лише одна з них містить значення True (не "None" або порожній рядок):

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

^Оператор , здається, побітовое і не визначені на всіх об'єктах:

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

Якщо ви вже нормалізуєте вхідні дані в булеві, то! = Це xor.

bool(a) != bool(b)

Ви завжди можете використовувати визначення xor для обчислення його з інших логічних операцій:

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

Але це трохи занадто багатослівно для мене, і це не особливо ясно на перший погляд. Ще один спосіб зробити це:

bool(a) ^ bool(b)

Оператор xor на двох булевих елементах є логічним xor (на відміну від ints, де це порозрядне). Що має сенс, оскількиbool є лише підкласомint , але реалізується лише для значень 0і 1. І логічний xor еквівалентний порозрядному xor, коли домен обмежений до 0та1 .

Отже, logical_xorфункція буде реалізовуватися так:

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

Кредит Ніку Коглану в списку розсилки Python-3000 .

Побітовий ексклюзив - або вже вбудований в Python в operatorмодулі (який ідентичний ^оператору):

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

Як пояснив Зак , ви можете використовувати:

xor = bool(a) ^ bool(b)

Особисто я віддаю перевагу дещо іншому діалекту:

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

Цей діалект натхненний мовою логічного діаграмування, яку я вивчив у школі, де "АБО" позначався коробкою, що містить ≥1(більше або дорівнює 1), а "XOR" позначається коробкою, що містить =1.

Це має перевагу в правильній реалізації ексклюзивних або на декількох операндах.

• "1 = a ^ b ^ c ..." означає кількість істинних операндів непарне. Цей оператор - «паритет».
• "1 = a + b + c ..." означає точно один операнд. Це "виключно або", що означає "одне до виключення інших".

• Python логічні or: A or B: повертається , Aякщо bool(A)є True, в іншому випадку повертаєтьсяB
• Python логічні and: A and B: повертається , Aякщо bool(A)є False, в іншому випадку повертаєтьсяB

Щоб дотримуватися більшості такого способу мислення, моїм логічним визначенням xor було б:

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

Таким чином , він може повернутися a, bабо False:

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

Я перевірив кілька підходів і not a != (not b) виявився найшвидшим.

Ось кілька тестів

%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

Редагувати: у прикладах 1 та 3 вище відсутні дужки, тому результат неправильний. Нові результати + truth()функція, як запропонував 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

Нагородження нитки:

Ідея анодера ... Просто ви спробуйте (може бути) пітонічний вираз «не», щоб отримати поведінку логічного «xor»

Таблиця правди:

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

А для вашого прикладу рядок:

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

Однак; як вони вказали вище, це залежить від фактичної поведінки, яку ви хочете витягнути про будь-які пару струн, тому що струни не є boleans ... і навіть більше: якщо ви «зануриться в Python», ви знайдете «Своєрідний характер» і "і" або "» http://www.diveintopython.net/power_of_introspection/and_or.html

Вибачте за мою написану англійську, це не моя рідна мова.

З повагою

У Python є ексклюзивний оператор АБО АБО ^:

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

Ви можете використовувати його, перетворивши вхідні дані в булі, перш ніж застосувати xor ( ^):

bool(a) ^ bool(b)

(Відредаговано - дякую Арел)

Оскільки я не бачу простого варіанту xor, що використовує змінні аргументи та лише операції зі значеннями Truth True або False, я просто кину його сюди для будь-кого. Як зазначають інші, досить (не сказати дуже) прямо.

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

І використання також просто:

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

Оскільки це узагальнений n-арний логічний XOR, це значення істини буде True, коли число True операндів непарне (і не тільки тоді, коли саме один True, це лише один випадок, коли n-arry XOR є True).

Таким чином, якщо ви шукаєте n-ary присудок, який є істинним лише тоді, коли саме один з його операндів є, ви можете використовувати:

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

Виключний або визначається наступним чином

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

Іноді мені здається, що я працюю з 1 і 0 замість булевих значень True та False. У цьому випадку xor можна визначити як

z = (x + y) % 2

яка має таку таблицю істинності:

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

Я знаю, що це пізно, але я подумав, і це, можливо, варто лише для документації. Можливо, це спрацювало б: np.abs(x-y)ідея така

1. якщо x = True = 1 і y = False = 0, то результат буде | 1-0 | = 1 = True
2. якщо x = False = 0 і y = False = 0, то результат буде | 0-0 | = 0 = False
3. якщо x = True = 1 і y = True = 1, результат буде | 1-1 | = 0 = Неправильно
4. якщо x = False = 0 і y = True = 1, результат буде | 0-1 | = 1 = True

Простий, зрозумілий:

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

Якщо ексклюзивний вибір - це те, що ви хочете, його можна розширити на кілька аргументів:

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

Як щодо цього?

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

дасть, aякщо bнеправда
, дасть, bякщо aнеправда
дастьFalse інакше

Або з потрійним виразом Python 2.5+:

(False if a else b) if b else a

Деякі із запропонованих тут реалізацій спричинять неодноразову оцінку операндів у деяких випадках, що може призвести до непередбачуваних побічних ефектів, і тому їх слід уникати.

Однак, xorреалізація, яка повертає Trueабо Falseє досить простою; той, який повертає один із операндів, якщо це можливо, набагато складніше, оскільки не існує єдиної думки щодо того, який операнд повинен бути обраним, особливо, коли є більше двох операндів. Наприклад, повинен xor(None, -1, [], True)повернутися None, []або False? Надіваюся, кожна відповідь деяким людям видається найбільш інтуїтивно зрозумілою.

Для істинного, і для хибного результату існує цілих п'ять можливих варіантів: повернути перший операнд (якщо він відповідає кінцевому результату у значенні, ще булевий), повернути перший збіг (якщо принаймні один існує, ще булевий), повернути останній операнд (якщо ... інше ...), повернути останнє збіг (якщо ... інше ...) або завжди повернути булевий. Загалом, це 5 ** 2 = 25 смаків 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()

Багатьом людям, включаючи мене, потрібна xorфункція, яка поводиться як n-вхідна схема xor, де n є змінною. (Див. Https://en.wikipedia.org/wiki/XOR_gate ). Наступна проста функція реалізує це.

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)

Наступний зразок вводу / виводу:

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

Щоб отримати логічний xor двох або більше змінних у Python:

1. Перетворення входів на булеві
2. Використовуйте оператор побітового xor ( ^або operator.xor)

Наприклад,

bool(a) ^ bool(b)

Коли ви перетворюєте входи в булеві, побітовий xor стає логічним xor.

Зауважте, що прийнята відповідь є невірною: != не тотожна xor в Python через тонкість ланцюга оператора .

Наприклад, xor з трьох наведених нижче значень є неправильним при використанні !=:

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

(PS Я спробував редагувати прийняту відповідь, щоб включити це попередження, але мою зміну було відхилено.)

Це легко, коли ви знаєте, що робить 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))

Це отримує логічний ексклюзивний XOR для двох (або більше) змінних

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

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

Перша проблема цієї установки полягає в тому, що вона, швидше за все, двічі проходить весь список і, як мінімум, двічі перевірить принаймні один з елементів. Таким чином, це може збільшити розуміння коду, але воно не надає швидкості (що може незначно відрізнятися залежно від випадку використання).

Друга проблема цієї установки полягає в тому, що вона перевіряє ексклюзивність незалежно від кількості змінних. Спочатку це може розглядатися як особливість, але перша проблема стає набагато більш значною, оскільки кількість змінних збільшується (якщо вони коли-небудь є).

Xor знаходиться ^в Python. Він повертає:

• Бітовий xor для ints
• Логічний xor для bools
• Ексклюзивна спілка для наборів
• Результати, визначені користувачем для класів, які реалізуються __xor__.
• TypeError для невизначених типів, таких як рядки або словники.

Якщо ви все одно маєте намір використовувати їх на рядках, їх кастинг boolробить вашу операцію однозначною (ви також можете мати на увазі set(str1) ^ set(str2)).

XOR реалізований в operator.xor.

Ось так я б кодував будь-яку таблицю істинності. Зокрема, для xor ми маємо:

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

Просто подивіться на значення T у стовпці відповідей та з'єднайте всі справжні випадки з логічним або. Отже, ця таблиця істинності може бути складена у випадку 2 або 3. Отже,

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

Ми можемо легко знайти xor двох змінних, використовуючи:

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

Приклад:

xor (Правда, помилково) >>> Істинно