Pythonで2つの変数の論理xorを取得するにはどうすればよいですか？

Pythonで2つの変数の論理xorを取得するにはどうすればよいですか？

たとえば、文字列であると予想される2つの変数があります。それらの1つだけに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)

2つのブール値のxor演算子は論理xorです（ビット単位のintとは異なります）。boolは単なるのサブクラスなintので、これは理にかなっていますが、値0とのみを持つように実装されています1。また、ドメインが0andに制限されている場合、論理xorはビット単位のxorと同等1です。

したがって、logical_xor関数は次のように実装されます。

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

Python-3000メーリングリストのNick Coghlan氏の功績によるものです。

ビット単位の排他的論理和は、operatorモジュール（^演算子と同じ）で既にPythonに組み込まれています。

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

この方言は、私が学校で学んだ論理的な作図言語からインスピレーションを得ており、「OR」は≥1（1以上）を含むボックスで示され、「XOR」はを含むボックスで示されていました。=1。

これには、排他的または複数のオペランドに正しく実装できるという利点があります。

• 「1 = a ^ b ^ c ...」は、真のオペランドの数が奇数であることを意味します。この演算子は「パリティ」です。
• 「1 = a + b + c ...」は、1つのオペランドが真であることを意味します。これは「排他的論理和」であり、「他のものを除外する」という意味です。

• 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

やりがいのあるスレッド：

Anoderの考え...論理的な«xor»の動作を取得するために、Pythonの式（そうではない可能性があります）を試してみてください

真理値表は次のようになります。

>>> 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 Peculiar Nature of "が見つかりますおよび」または「または」» http://www.diveintopython.net/power_of_introspection/and_or.html

申し訳ありませんが、私の英語は私の母国語ではありません。

よろしく。

Pythonにはビット単位の排他的OR演算子があります^。

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

xor（^）を適用する前に入力をブール値に変換することで使用できます。

bool(a) ^ bool(b)

（編集-ありがとうArel）

変数引数を使用した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-ary論理XORであるため、Trueオペランドの数が奇数の場合は常に真の値がTrueになります（正確に1つがTrueの場合だけでなく、これはn-ary XORがTrueの場合の1つにすぎません）。

したがって、オペランドの1つだけが真である場合にのみTrueであるn項述語を検索する場合は、次のように使用できます。

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)

ブール値のTrueとFalseの値の代わりに1と0を使用していることがあります。この場合、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はfalseが
与えるb場合はafalseで
与えるFalseそう

または、Python 2.5以降の3項式を使用します。

(False if a else b) if b else a

ここで提案されている実装の一部は、場合によってはオペランドの繰り返し評価を引き起こし、意図しない副作用を引き起こす可能性があるため、回避する必要があります。

そうは言っても、xorどちらかを返すか、TrueまたはFalseかなり単純な実装です。特に2つ以上のオペランドがある場合、どのオペランドを選択するかについてコンセンサスが存在しないため、可能であれば、オペランドの1つを返すものはよりトリッキーです。たとえば、必要がありますxor(None, -1, [], True)返すNone、[]またはFalse？私はそれぞれの答えが最も直感的なものとして何人かの人々に見えるに違いない。

TrueまたはFalseの結果の場合、最大5つの選択肢があります。最初のオペランドを返す（最終結果と値が一致する場合はブール値）、最初の一致を返す（少なくとも1つが存在する場合はブール値）、最後のオペランドを返す（if ... else ...）、最後の一致を返す（if ... else ...）、または常にブール値を返します。要するに、これは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()

私を含む多くの人々は、xornが変数であるn入力xor回路のように動作する関数を必要としています。（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)

サンプル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

Pythonで2つ以上の変数の論理xorを取得するには：

1. 入力をブール値に変換する
2. ビットごとのxor演算子（^またはoperator.xor）を使用する

例えば、

bool(a) ^ bool(b)

入力をブール値に変換すると、ビット単位の xorは論理 xorになります。

受け入れられた答えは間違っていることに注意してください： 演算子チェーンの!=微妙さのため、Pythonのxorと同じではありません。

たとえば、以下を使用する場合、以下の3つの値の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))

これは、2つ（またはそれ以上）の変数の論理排他XORを取得します

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

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

この設定の最初の問題は、リスト全体を2回トラバースする可能性が高く、少なくとも、要素の少なくとも1つを2回チェックすることです。そのため、コードの理解度は高まるかもしれませんが、速度には向いていません（ユースケースによっては無視できる程度の違いになるかもしれません）。

このセットアップの2番目の問題は、変数の数に関係なく排他性をチェックすることです。これは最初は機能と見なされるかもしれませんが、変数の数が増えると（最初の問題はさらに大きくなります）、さらに重要になります。

Xorは^Pythonです。それは返します：

• intのビット単位のxor
• ブールの論理XOR
• セット専用の組合
• を実装するクラスのユーザー定義の結果__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値を見て、論理ORですべての真のケースをつなぎ合わせます。したがって、この真理値表は、ケース2または3で生成される可能性があります。したがって、

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

次のコマンドを使用すると、2つの変数のxorを簡単に見つけることができます。

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

例：

xor（True、False）>>> True