파이썬에서 두 변수의 논리 xor를 어떻게 얻습니까?

파이썬에서 두 변수 의 논리 xor 를 어떻게 얻 습니까?

예를 들어 문자열이 될 것으로 예상되는 두 가지 변수가 있습니다. 그중 하나만 True 값을 포함하는지 테스트하고 싶습니다 (없음 또는 빈 문자열이 아님).

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입니다 (비트 단위의 int와 달리). bool의 하위 클래스int 이기 때문에 의미 가 있지만 0및 값만 갖도록 구현됩니다 1. 그리고 논리 xor는 도메인이 0및 로 제한 될 때 비트 xor 와 같습니다 1.

따라서 logical_xor기능은 다음과 같이 구현됩니다.

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

Python-3000 메일 링리스트 에서 Nick Coghlan 에게 감사의 말을 전합니다 .

비트 배타적-또는 이미 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

이 방언은 학교에서 배운 논리적 다이어그램 언어에서 영감을 얻었습니다. 여기서 "OR"은 ≥1(1 이상)을 포함하는 상자로 표시되고 "XOR"은를 포함하는 상자로 표시됩니다 =1.

이는 배타적이거나 여러 피연산자를 올바르게 구현할 수 있다는 이점이 있습니다.

• "1 = a ^ b ^ c ..."는 실제 피연산자의 수가 홀수임을 나타냅니다. 이 연산자는 "패리티"입니다.
• "1 = a + b + c ..."는 정확히 하나의 피연산자가 참임을 의미합니다. 이것은 "배타적"또는 "다른 것의 배제"를 의미합니다.

• Python logical or: A or B: is를 반환 A하고 , 그렇지 않으면를 반환bool(A)TrueB
• Python logical and: A and B: is를 반환 A하고 , 그렇지 않으면를 반환bool(A)FalseB

이러한 사고 방식을 대부분 유지하기 위해 나의 논리적 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 idea ... 논리적 인«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가 아니기 때문에 커플 문자열에 대해 꺼내려는 실제 동작에 따라 다릅니다. and "및"or "» http://www.diveintopython.net/power_of_introspection/and_or.html

내가 쓴 영어가 미안하지만, 그것은 내가 태어난 언어가 아닙니다.

문안 인사.

파이썬에는 비트 배타적 OR 연산자가 있습니다 ^.

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

xor ( ^) 를 적용하기 전에 입력을 부울로 변환하여 사용할 수 있습니다 .

bool(a) ^ bool(b)

(편집-감사 Arel)

변수 인수를 사용하는 xor의 간단한 변형을 보지 않고 진실 값 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!"

이것은 일반화 된 이진 논리 XOR이므로, 참 피연산자의 수가 홀수 일 때마다 참 값이 참이됩니다 (정확히 하나가 참일 때뿐만 아니라, 이진 XOR이 참인 경우에 한합니다).

따라서 정확히 하나의 피연산자 중 하나 일 때만 참인 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)

때로는 부울 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거짓 인
줄 것이다 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-result의 경우 가능한 5 가지 선택 사항이 있습니다. 첫 번째 피연산자 리턴 (값이 최종 결과와 일치하는 경우 부울 임), 첫 번째 일치 리턴 (최소 하나가 존재하는 경우 부울) 마지막 피연산자 반환 (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()

나 자신을 포함한 많은 사람들 xor은 n 입력 변수 인 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

파이썬에서 두 개 이상의 변수의 논리 xor를 얻으려면 :

1. 입력을 부울로 변환
2. 비트 xor 연산자 ( ^또는 operator.xor)를 사용하십시오.

예를 들어

bool(a) ^ bool(b)

입력을 부울로 변환하면 비트 xor가 논리 xor가됩니다.

허용되는 답변이 잘못되었다는 점에 유의하십시오 . 연산자 체인!= 의 미묘함으로 인해 Python의 xor와 동일하지 않습니다 .

예를 들어, 다음 세 가지 값 중 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
• 세트를위한 독점 조합
• 를 구현하는 클래스에 대한 사용자 정의 결과 __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 (참, 거짓) >>> 참