Làm thế nào để bạn có được xor logic của hai biến trong Python?

Làm thế nào để bạn có được xor logic của hai biến trong Python?

Ví dụ, tôi có hai biến mà tôi mong đợi là chuỗi. Tôi muốn kiểm tra rằng chỉ một trong số chúng chứa giá trị True (không phải là Không hoặc chuỗi trống):

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

Các ^nhà điều hành có vẻ là Bitwise, và không xác định trên tất cả các đối tượng:

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

Nếu bạn đã bình thường hóa đầu vào thành booleans, thì! = Là xor.

bool(a) != bool(b)

Bạn luôn có thể sử dụng định nghĩa của xor để tính toán nó từ các hoạt động logic khác:

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

Nhưng điều này hơi quá dài dòng đối với tôi và không đặc biệt rõ ràng ngay từ cái nhìn đầu tiên. Một cách khác để làm điều đó là:

bool(a) ^ bool(b)

Toán tử xor trên hai booleans là xor logic (không giống như trên ints, trong đó bitwise). Điều này có nghĩa, vì boolchỉ là một lớp con củaint , nhưng được triển khai để chỉ có các giá trị 0và 1. Và xor logic tương đương với xwise bitwise khi miền bị giới hạn 0và 1.

Vì vậy, logical_xorchức năng sẽ được thực hiện như sau:

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

Tín dụng cho Nick Coghlan trong danh sách gửi thư Python-3000 .

Bitwise độc quyền - hoặc đã được tích hợp sẵn trong Python, trong operatormô-đun (giống hệt với ^toán tử):

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

Như Zach đã giải thích, bạn có thể sử dụng:

xor = bool(a) ^ bool(b)

Cá nhân, tôi ủng hộ một phương ngữ hơi khác:

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

Phương ngữ này được lấy cảm hứng từ một ngôn ngữ lập biểu đồ logic mà tôi đã học ở trường nơi "HOẶC" được biểu thị bằng một hộp chứa ≥1(lớn hơn hoặc bằng 1) và "XOR" được biểu thị bằng một hộp chứa =1.

Điều này có lợi thế của việc thực hiện chính xác độc quyền hoặc trên nhiều toán hạng.

• "1 = a ^ b ^ c ..." có nghĩa là số toán hạng thực là số lẻ. Toán tử này là "chẵn lẻ".
• "1 = a + b + c ..." có nghĩa chính xác một toán hạng là đúng. Đây là "độc quyền hoặc", có nghĩa là "một loại trừ những cái khác".

• Python logic or:: A or Btrả về Anếu bool(A)là True, nếu không thì trả vềB
• Python logic and:: A and Btrả về Anếu bool(A)là False, nếu không thì trả vềB

Để giữ phần lớn lối suy nghĩ đó, định nghĩa xor logic của tôi sẽ là:

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

Bằng cách đó nó có thể quay trở lại a, bhoặc False:

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

Tôi đã thử nghiệm một số cách tiếp cận và not a != (not b)dường như là nhanh nhất.

Dưới đây là một số bài kiểm tra

%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

Chỉnh sửa: Ví dụ 1 và 3 ở trên thiếu dấu ngoặc đơn nên kết quả không chính xác. Kết quả mới + truth()chức năng như ShadowRanger đề xuất.

%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

Phần thưởng:

Ý tưởng về bộ giải mã ... Chỉ cần bạn thử biểu thức pythonic (có thể) «không» để có được hành vi logic «xor»

Bảng sự thật sẽ là:

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

Và cho chuỗi ví dụ của bạn:

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

Tuy nhiên; như họ đã chỉ ra ở trên, nó phụ thuộc vào hành vi thực tế mà bạn muốn rút ra về bất kỳ chuỗi nào, bởi vì chuỗi không phải là ... và thậm chí hơn thế nữa: nếu bạn «Đi sâu vào Python», bạn sẽ tìm thấy «Bản chất đặc biệt của" và "và" hoặc "» http://www.diveintopython.net/power_of_introspection/and_or.html

Xin lỗi tiếng Anh viết của tôi, nó không phải là ngôn ngữ sinh ra của tôi.

Trân trọng.

Python có toán tử OR độc quyền bitwise, đó là ^:

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

Bạn có thể sử dụng nó bằng cách chuyển đổi các đầu vào thành booleans trước khi áp dụng xor ( ^):

bool(a) ^ bool(b)

(Đã chỉnh sửa - cảm ơn Arel)

Vì tôi không thấy biến thể đơn giản của xor khi sử dụng các đối số biến và chỉ hoạt động trên các giá trị Truth Đúng hoặc Sai, tôi sẽ chỉ ném nó ở đây cho bất kỳ ai sử dụng. Nó được ghi nhận bởi những người khác, khá đơn giản (không phải nói rất nhiều).

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

Và việc sử dụng cũng đơn giản:

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

Vì đây là XOR logic n-ary tổng quát, nên giá trị thật của nó sẽ là True bất cứ khi nào số toán hạng True là số lẻ (và không chỉ khi chính xác một là True, đây chỉ là một trường hợp trong đó XOR của n-ary là True).

Do đó, nếu bạn đang tìm kiếm một vị từ n-ary chỉ đúng khi chính xác một trong các toán hạng của nó, bạn có thể muốn sử dụng:

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

Độc quyền Hoặc được định nghĩa như sau

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

Đôi khi tôi thấy mình làm việc với 1 và 0 thay vì giá trị boolean Đúng và Sai. Trong trường hợp này xor có thể được định nghĩa là

z = (x + y) % 2

trong đó có bảng chân lý sau:

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

Tôi biết điều này là muộn, nhưng tôi đã có một suy nghĩ và nó có thể có giá trị, chỉ để làm tài liệu. Có lẽ điều này sẽ làm việc: np.abs(x-y)Ý tưởng là

1. nếu x = True = 1 và y = false = 0 thì kết quả sẽ là | 1-0 | = 1 = True
2. nếu x = Sai = 0 và y = Sai = 0 thì kết quả sẽ là | 0-0 | = 0 = Sai
3. nếu x = True = 1 và y = True = 1 thì kết quả sẽ là | 1-1 | = 0 = Sai
4. if x = false = 0 và y = True = 1 thì kết quả sẽ là | 0-1 | = 1 = True

Đơn giản, dễ hiểu:

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

Nếu một lựa chọn độc quyền là những gì bạn theo đuổi, nó có thể được mở rộng thành nhiều đối số:

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

Còn cái này thì sao?

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

sẽ cho anếu blà sai
sẽ cho bnếu alà sai
sẽ cho Falsekhác

Hoặc với biểu thức ternary Python 2.5+:

(False if a else b) if b else a

Một số triển khai được đề xuất ở đây sẽ gây ra sự đánh giá lặp lại của các toán hạng trong một số trường hợp, điều này có thể dẫn đến các tác dụng phụ ngoài ý muốn và do đó phải tránh.

Điều đó nói rằng, xorviệc thực hiện trả về một trong hai Truehoặc Falsekhá đơn giản; một cái trả về một trong các toán hạng, nếu có thể, sẽ phức tạp hơn nhiều, bởi vì không có sự đồng thuận nào tồn tại như toán hạng nào nên được chọn, đặc biệt là khi có nhiều hơn hai toán hạng. Chẳng hạn, nên xor(None, -1, [], True)trả lại None, []hay False? Tôi đặt cược mỗi câu trả lời xuất hiện cho một số người là câu trả lời trực quan nhất.

Đối với kết quả Đúng hoặc Kết quả sai, có tối đa năm lựa chọn có thể: trả về toán hạng đầu tiên (nếu nó khớp với kết quả cuối cùng về giá trị, khác boolean), trả về kết quả khớp đầu tiên (nếu có ít nhất một tồn tại, khác boolean), trả về toán hạng cuối cùng (nếu ... khác ...), trả về kết quả cuối cùng (nếu ... khác ...) hoặc luôn trả về boolean. Nhìn chung, đó là 5 ** 2 = 25 hương vị của 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()

Nhiều người, bao gồm cả bản thân tôi, cần một xorchức năng hoạt động như một mạch xor đầu vào n, trong đó n là biến. (Xem https://en.wikipedia.org/wiki/XOR_gate ). Các chức năng đơn giản sau đây thực hiện điều này.

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)

Mẫu I / O sau:

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

Để có được xor logic của hai hoặc nhiều biến trong Python:

1. Chuyển đổi đầu vào thành booleans
2. Sử dụng toán tử xor bitwise ( ^hoặc operator.xor)

Ví dụ,

bool(a) ^ bool(b)

Khi bạn chuyển đổi các đầu vào thành booleans, bitwise xor trở thành xor logic .

Lưu ý rằng câu trả lời được chấp nhận là sai: != không giống như xor trong Python vì sự tinh tế của chuỗi toán tử .

Chẳng hạn, xor của ba giá trị dưới đây là sai khi sử dụng !=:

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

(PS Tôi đã thử chỉnh sửa câu trả lời được chấp nhận để đưa vào cảnh báo này, nhưng thay đổi của tôi đã bị từ chối.)

Thật dễ dàng khi bạn biết XOR làm gì:

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

Điều này nhận được XOR độc quyền logic cho hai (hoặc nhiều) biến

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

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

Vấn đề đầu tiên với thiết lập này là rất có thể nó đi qua toàn bộ danh sách hai lần và, ở mức tối thiểu, sẽ kiểm tra ít nhất một trong các yếu tố hai lần. Vì vậy, nó có thể tăng khả năng hiểu mã, nhưng nó không cho vay tốc độ (có thể khác nhau tùy theo trường hợp sử dụng của bạn).

Vấn đề thứ hai với thiết lập này là nó kiểm tra tính độc quyền bất kể số lượng biến. Điều này ban đầu có thể được coi là một tính năng, nhưng vấn đề đầu tiên trở nên quan trọng hơn rất nhiều khi số lượng biến tăng (nếu chúng từng làm).

Xor là ^trong Python. Nó trở lại :

• Một xor bitwise cho ints
• Xor logic cho bools
• Một liên minh độc quyền cho các bộ
• Kết quả do người dùng định nghĩa cho các lớp thực hiện __xor__.
• TypeError cho các loại không xác định, chẳng hạn như chuỗi hoặc từ điển.

Nếu bạn có ý định sử dụng chúng trên các chuỗi bằng mọi cách, việc đưa chúng vào boollàm cho hoạt động của bạn không rõ ràng (bạn cũng có thể có nghĩa set(str1) ^ set(str2)).

XOR được thực hiện trong operator.xor.

Đây là cách tôi sẽ mã hóa bất kỳ bảng sự thật. Đối với xor nói riêng, chúng tôi có:

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

Chỉ cần nhìn vào các giá trị T trong cột trả lời và xâu chuỗi tất cả các trường hợp đúng với logic hoặc. Vì vậy, bảng chân lý này có thể được sản xuất trong trường hợp 2 hoặc 3. Do đó,

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

Chúng ta có thể dễ dàng tìm thấy xor của hai biến bằng cách sử dụng:

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

Thí dụ:

xor (Đúng, Sai) >>> Đúng