Как вы получаете логический 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'

Если вы уже нормализуете входные данные для логических значений, тогда! = Is xor.

bool(a) != bool(b)

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

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

Но для меня это слишком многословно и на первый взгляд не совсем понятно. Еще один способ сделать это:

bool(a) ^ bool(b)

Оператор xor на двух логических значениях является логическим xor (в отличие от целых, где он побитовый). Что имеет смысл, так как 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
>>> 

Однако; как они указали выше, это зависит от фактического поведения, которое вы хотите извлечь из любой пары строк, потому что строки не являются логическими значениями ... и даже более того: если вы «Dive Into Python», вы найдете «The Pegetarian Nature» и «и» или «» 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, использующего переменные аргументы и только операции со значениями True, 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-арный XOR равен True).

Таким образом, если вы ищете n-арный предикат, который имеет значение True только тогда, когда есть только один из его операндов, вы можете использовать:

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 = False
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 ? Могу поспорить, что каждый ответ кажется некоторым людям наиболее интуитивным.

Для True- или 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функция, которая ведет себя как схема x-n-входа, где 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 для целых
• Логический xor для bools
• Эксклюзивный союз для наборов
• Пользовательские результаты для классов, которые реализуют __xor__ .
• Ошибка типа для неопределенных типов, таких как строки или словари.

Если вы все равно намереваетесь использовать их для строк, приведение к ним 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 (верно, неверно) >>> верно