How do you get the logical xor of two variables in Python?
For example, I have two variables that I expect to be strings. I want to test that only one of them contains a True value (is not None or the empty string):
str1 = raw_input("Enter string one:")
str2 = raw_input("Enter string two:")
if logical_xor(str1, str2):
print "ok"
else:
print "bad"
The ^ operator seems to be bitwise, and not defined on all objects:
>>> 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'
This question is related to
python
logical-operators
Many folks, including myself, need an xor function that behaves like an n-input xor circuit, where n is variable. (See https://en.wikipedia.org/wiki/XOR_gate). The following simple function implements this.
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)
Sample I/O follows:
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
How about this?
(not b and a) or (not a and b)
will give a if b is false
will give b if a is false
will give False otherwise
Or with the Python 2.5+ ternary expression:
(False if a else b) if b else a
Python has a bitwise exclusive-OR operator, it's ^:
>>> True ^ False
True
>>> True ^ True
False
>>> False ^ True
True
>>> False ^ False
False
You can use it by converting the inputs to booleans before applying xor (^):
bool(a) ^ bool(b)
(Edited - thanks Arel)
Bitwise exclusive-or is already built-in to Python, in the operator module (which is identical to the ^ operator):
from operator import xor
xor(bool(a), bool(b)) # Note: converting to bools is essential
Exclusive Or is defined as follows
def xor( a, b ):
return (a or b) and not (a and b)
The way that Python handles logic operations can be confusing, so my implementation gives the user the option (by default) of a simple True/False answer. The actual Python result can be obtained by setting the optional third arg to None.
def xor(a, b, true=True, false=False): # set true to None to get actual Python result
ab1 = a and not b
ab2 = not a and b
if bool(ab1) != bool(ab2):
return (ab1 or ab2) if true is None else true
else:
return false
You can always use the definition of xor to compute it from other logical operations:
(a and not b) or (not a and b)
But this is a little too verbose for me, and isn't particularly clear at first glance. Another way to do it is:
bool(a) ^ bool(b)
The xor operator on two booleans is logical xor (unlike on ints, where it's bitwise). Which makes sense, since bool is just a subclass of int, but is implemented to only have the values 0 and 1. And logical xor is equivalent to bitwise xor when the domain is restricted to 0 and 1.
So the logical_xor function would be implemented like:
def logical_xor(str1, str2):
return bool(str1) ^ bool(str2)
Credit to Nick Coghlan on the Python-3000 mailing list.
def xor(*args):
return sum(bool(arg) for arg in args)%2
if you want only one true:
def onlyOne(*args):
return sum(bool(arg) for arg in args)==1
Rewarding thread:
Anoder idea... Just you try the (may be) pythonic expression «is not» in order to get behavior of logical «xor»
The truth table would be:
>>> True is not True
False
>>> True is not False
True
>>> False is not True
True
>>> False is not False
False
>>>
And for your example string:
>>> "abc" is not ""
True
>>> 'abc' is not 'abc'
False
>>> 'abc' is not ''
True
>>> '' is not 'abc'
True
>>> '' is not ''
False
>>>
However; as they indicated above, it depends of the actual behavior you want to pull out about any couple strings, because strings aren't boleans... and even more: if you «Dive Into Python» you will find «The Peculiar Nature of "and" and "or"» http://www.diveintopython.net/power_of_introspection/and_or.html
Sorry my writed English, it's not my born language.
Regards.
Exclusive Or is defined as follows
def xor( a, b ):
return (a or b) and not (a and b)
Python has a bitwise exclusive-OR operator, it's ^:
>>> True ^ False
True
>>> True ^ True
False
>>> False ^ True
True
>>> False ^ False
False
You can use it by converting the inputs to booleans before applying xor (^):
bool(a) ^ bool(b)
(Edited - thanks Arel)
Rewarding thread:
Anoder idea... Just you try the (may be) pythonic expression «is not» in order to get behavior of logical «xor»
The truth table would be:
>>> True is not True
False
>>> True is not False
True
>>> False is not True
True
>>> False is not False
False
>>>
And for your example string:
>>> "abc" is not ""
True
>>> 'abc' is not 'abc'
False
>>> 'abc' is not ''
True
>>> '' is not 'abc'
True
>>> '' is not ''
False
>>>
However; as they indicated above, it depends of the actual behavior you want to pull out about any couple strings, because strings aren't boleans... and even more: if you «Dive Into Python» you will find «The Peculiar Nature of "and" and "or"» http://www.diveintopython.net/power_of_introspection/and_or.html
Sorry my writed English, it's not my born language.
Regards.
To get the logical xor of two or more variables in Python:
^ or operator.xor)For example,
bool(a) ^ bool(b)
When you convert the inputs to booleans, bitwise xor becomes logical xor.
Note that the accepted answer is wrong: != is not the same as xor in Python because of the subtlety of operator chaining.
For instance, the xor of the three values below is wrong when using !=:
True ^ False ^ False # True, as expected of XOR
True != False != False # False! Equivalent to `(True != False) and (False != False)`
(P.S. I tried editing the accepted answer to include this warning, but my change was rejected.)
You can always use the definition of xor to compute it from other logical operations:
(a and not b) or (not a and b)
But this is a little too verbose for me, and isn't particularly clear at first glance. Another way to do it is:
bool(a) ^ bool(b)
The xor operator on two booleans is logical xor (unlike on ints, where it's bitwise). Which makes sense, since bool is just a subclass of int, but is implemented to only have the values 0 and 1. And logical xor is equivalent to bitwise xor when the domain is restricted to 0 and 1.
So the logical_xor function would be implemented like:
def logical_xor(str1, str2):
return bool(str1) ^ bool(str2)
Credit to Nick Coghlan on the Python-3000 mailing list.
XOR is implemented in operator.xor.
I know this is late, but I had a thought and it might be worth, just for documentation. Perhaps this would work:np.abs(x-y) The idea is that
As I don't see the simple variant of xor using variable arguments and only operation on Truth values True or False, I'll just throw it here for anyone to use. It's as noted by others, pretty (not to say very) straightforward.
def xor(*vars):
result = False
for v in vars:
result = result ^ bool(v)
return result
And usage is straightforward as well:
if xor(False, False, True, False):
print "Hello World!"
As this is the generalized n-ary logical XOR, it's truth value will be True whenever the number of True operands is odd (and not only when exactly one is True, this is just one case in which n-ary XOR is True).
Thus if you are in search of a n-ary predicate that is only True when exactly one of it's operands is, you might want to use:
def isOne(*vars):
result = False
for v in vars:
if result and v:
return False
else:
result = result or v
return result
Simple, easy to understand:
sum(bool(a), bool(b)) == 1
If an exclusive choice is what you're after, i.e. to select 1 choice out of n, it can be expanded to multiple arguments:
sum(bool(x) for x in y) == 1
Sometimes I find myself working with 1 and 0 instead of boolean True and False values. In this case xor can be defined as
z = (x + y) % 2
which has the following truth table:
x
|0|1|
-+-+-+
0|0|1|
y -+-+-+
1|1|0|
-+-+-+
XOR is implemented in operator.xor.
Xor is ^ in Python. It returns :
__xor__.If you intend to use them on strings anyway, casting them in bool makes your operation unambiguous (you could also mean set(str1) ^ set(str2)).
Sometimes I find myself working with 1 and 0 instead of boolean True and False values. In this case xor can be defined as
z = (x + y) % 2
which has the following truth table:
x
|0|1|
-+-+-+
0|0|1|
y -+-+-+
1|1|0|
-+-+-+
Some of the implementations suggested here will cause repeated evaluation of the operands in some cases, which may lead to unintended side effects and therefore must be avoided.
That said, a xor implementation that returns either True or False is fairly simple; one that returns one of the operands, if possible, is much trickier, because no consensus exists as to which operand should be the chosen one, especially when there are more than two operands. For instance, should xor(None, -1, [], True) return None, [] or False? I bet each answer appears to some people as the most intuitive one.
For either the True- or the False-result, there are as many as five possible choices: return first operand (if it matches end result in value, else boolean), return first match (if at least one exists, else boolean), return last operand (if ... else ...), return last match (if ... else ...), or always return boolean. Altogether, that's 5 ** 2 = 25 flavors of 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()
This is how I would code up any truth table. For xor in particular we have:
| a | b | xor | |
|---|----|-------|-------------|
| T | T | F | |
| T | F | T | a and not b |
| F | T | T | not a and b |
| F | F | F | |
Just look at the T values in the answer column and string together all true cases with logical or. So, this truth table may be produced in case 2 or 3. Hence,
xor = lambda a, b: (a and not b) or (not a and b)
It's easy when you know what XOR does:
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))
As I don't see the simple variant of xor using variable arguments and only operation on Truth values True or False, I'll just throw it here for anyone to use. It's as noted by others, pretty (not to say very) straightforward.
def xor(*vars):
result = False
for v in vars:
result = result ^ bool(v)
return result
And usage is straightforward as well:
if xor(False, False, True, False):
print "Hello World!"
As this is the generalized n-ary logical XOR, it's truth value will be True whenever the number of True operands is odd (and not only when exactly one is True, this is just one case in which n-ary XOR is True).
Thus if you are in search of a n-ary predicate that is only True when exactly one of it's operands is, you might want to use:
def isOne(*vars):
result = False
for v in vars:
if result and v:
return False
else:
result = result or v
return result
or: A or B: returns A if bool(A) is True, otherwise returns Band: A and B: returns A if bool(A) is False, otherwise returns BTo keep most of that way of thinking, my logical xor definintion would be:
def logical_xor(a, b):
if bool(a) == bool(b):
return False
else:
return a or b
That way it can return a, b, or False:
>>> logical_xor('this', 'that')
False
>>> logical_xor('', '')
False
>>> logical_xor('this', '')
'this'
>>> logical_xor('', 'that')
'that'
Exclusive Or is defined as follows
def xor( a, b ):
return (a or b) and not (a and b)
Bitwise exclusive-or is already built-in to Python, in the operator module (which is identical to the ^ operator):
from operator import xor
xor(bool(a), bool(b)) # Note: converting to bools is essential
or: A or B: returns A if bool(A) is True, otherwise returns Band: A and B: returns A if bool(A) is False, otherwise returns BTo keep most of that way of thinking, my logical xor definintion would be:
def logical_xor(a, b):
if bool(a) == bool(b):
return False
else:
return a or b
That way it can return a, b, or False:
>>> logical_xor('this', 'that')
False
>>> logical_xor('', '')
False
>>> logical_xor('this', '')
'this'
>>> logical_xor('', 'that')
'that'
As Zach explained, you can use:
xor = bool(a) ^ bool(b)
Personally, I favor a slightly different dialect:
xor = bool(a) + bool(b) == 1
This dialect is inspired from a logical diagramming language I learned in school where "OR" was denoted by a box containing =1 (greater than or equal to 1) and "XOR" was denoted by a box containing =1.
This has the advantage of correctly implementing exclusive or on multiple operands.
I've tested several approaches and not a != (not b) appeared to be the fastest.
Here are some tests
%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
Edit:
Examples 1 and 3 above are missing parenthes so result is incorrect. New results + truth() function as ShadowRanger suggested.
%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
This gets the logical exclusive XOR for two (or more) variables
str1 = raw_input("Enter string one:")
str2 = raw_input("Enter string two:")
any([str1, str2]) and not all([str1, str2])
The first problem with this setup is that it most likely traverses the whole list twice and, at a minimum, will check at least one of the elements twice. So it may increase code comprehension, but it doesn't lend to speed (which may differ negligibly depending on your use case).
The second problem with this setup is that it checks for exclusivity regardless of the number of variables. This is may at first be regarded as a feature, but the first problem becomes a lot more significant as the number of variables increases (if they ever do).
Exclusive Or is defined as follows
def xor( a, b ):
return (a or b) and not (a and b)
We can easily find xor of two variables by the using:
def xor(a,b):
return a !=b
Example:
xor(True,False) >>> True
Xor is ^ in Python. It returns :
__xor__.If you intend to use them on strings anyway, casting them in bool makes your operation unambiguous (you could also mean set(str1) ^ set(str2)).
As Zach explained, you can use:
xor = bool(a) ^ bool(b)
Personally, I favor a slightly different dialect:
xor = bool(a) + bool(b) == 1
This dialect is inspired from a logical diagramming language I learned in school where "OR" was denoted by a box containing =1 (greater than or equal to 1) and "XOR" was denoted by a box containing =1.
This has the advantage of correctly implementing exclusive or on multiple operands.
How about this?
(not b and a) or (not a and b)
will give a if b is false
will give b if a is false
will give False otherwise
Or with the Python 2.5+ ternary expression:
(False if a else b) if b else a
You can always use the definition of xor to compute it from other logical operations:
(a and not b) or (not a and b)
But this is a little too verbose for me, and isn't particularly clear at first glance. Another way to do it is:
bool(a) ^ bool(b)
The xor operator on two booleans is logical xor (unlike on ints, where it's bitwise). Which makes sense, since bool is just a subclass of int, but is implemented to only have the values 0 and 1. And logical xor is equivalent to bitwise xor when the domain is restricted to 0 and 1.
So the logical_xor function would be implemented like:
def logical_xor(str1, str2):
return bool(str1) ^ bool(str2)
Credit to Nick Coghlan on the Python-3000 mailing list.
To get the logical xor of two or more variables in Python:
^ or operator.xor)For example,
bool(a) ^ bool(b)
When you convert the inputs to booleans, bitwise xor becomes logical xor.
Note that the accepted answer is wrong: != is not the same as xor in Python because of the subtlety of operator chaining.
For instance, the xor of the three values below is wrong when using !=:
True ^ False ^ False # True, as expected of XOR
True != False != False # False! Equivalent to `(True != False) and (False != False)`
(P.S. I tried editing the accepted answer to include this warning, but my change was rejected.)
Some of the implementations suggested here will cause repeated evaluation of the operands in some cases, which may lead to unintended side effects and therefore must be avoided.
That said, a xor implementation that returns either True or False is fairly simple; one that returns one of the operands, if possible, is much trickier, because no consensus exists as to which operand should be the chosen one, especially when there are more than two operands. For instance, should xor(None, -1, [], True) return None, [] or False? I bet each answer appears to some people as the most intuitive one.
For either the True- or the False-result, there are as many as five possible choices: return first operand (if it matches end result in value, else boolean), return first match (if at least one exists, else boolean), return last operand (if ... else ...), return last match (if ... else ...), or always return boolean. Altogether, that's 5 ** 2 = 25 flavors of 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()
I've tested several approaches and not a != (not b) appeared to be the fastest.
Here are some tests
%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
Edit:
Examples 1 and 3 above are missing parenthes so result is incorrect. New results + truth() function as ShadowRanger suggested.
%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
I know this is late, but I had a thought and it might be worth, just for documentation. Perhaps this would work:np.abs(x-y) The idea is that
How about this?
(not b and a) or (not a and b)
will give a if b is false
will give b if a is false
will give False otherwise
Or with the Python 2.5+ ternary expression:
(False if a else b) if b else a
As Zach explained, you can use:
xor = bool(a) ^ bool(b)
Personally, I favor a slightly different dialect:
xor = bool(a) + bool(b) == 1
This dialect is inspired from a logical diagramming language I learned in school where "OR" was denoted by a box containing =1 (greater than or equal to 1) and "XOR" was denoted by a box containing =1.
This has the advantage of correctly implementing exclusive or on multiple operands.
This gets the logical exclusive XOR for two (or more) variables
str1 = raw_input("Enter string one:")
str2 = raw_input("Enter string two:")
any([str1, str2]) and not all([str1, str2])
The first problem with this setup is that it most likely traverses the whole list twice and, at a minimum, will check at least one of the elements twice. So it may increase code comprehension, but it doesn't lend to speed (which may differ negligibly depending on your use case).
The second problem with this setup is that it checks for exclusivity regardless of the number of variables. This is may at first be regarded as a feature, but the first problem becomes a lot more significant as the number of variables increases (if they ever do).
This is how I would code up any truth table. For xor in particular we have:
| a | b | xor | |
|---|----|-------|-------------|
| T | T | F | |
| T | F | T | a and not b |
| F | T | T | not a and b |
| F | F | F | |
Just look at the T values in the answer column and string together all true cases with logical or. So, this truth table may be produced in case 2 or 3. Hence,
xor = lambda a, b: (a and not b) or (not a and b)
or: A or B: returns A if bool(A) is True, otherwise returns Band: A and B: returns A if bool(A) is False, otherwise returns BTo keep most of that way of thinking, my logical xor definintion would be:
def logical_xor(a, b):
if bool(a) == bool(b):
return False
else:
return a or b
That way it can return a, b, or False:
>>> logical_xor('this', 'that')
False
>>> logical_xor('', '')
False
>>> logical_xor('this', '')
'this'
>>> logical_xor('', 'that')
'that'
Many folks, including myself, need an xor function that behaves like an n-input xor circuit, where n is variable. (See https://en.wikipedia.org/wiki/XOR_gate). The following simple function implements this.
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)
Sample I/O follows:
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
You can always use the definition of xor to compute it from other logical operations:
(a and not b) or (not a and b)
But this is a little too verbose for me, and isn't particularly clear at first glance. Another way to do it is:
bool(a) ^ bool(b)
The xor operator on two booleans is logical xor (unlike on ints, where it's bitwise). Which makes sense, since bool is just a subclass of int, but is implemented to only have the values 0 and 1. And logical xor is equivalent to bitwise xor when the domain is restricted to 0 and 1.
So the logical_xor function would be implemented like:
def logical_xor(str1, str2):
return bool(str1) ^ bool(str2)
Credit to Nick Coghlan on the Python-3000 mailing list.
def xor(*args):
return sum(bool(arg) for arg in args)%2
if you want only one true:
def onlyOne(*args):
return sum(bool(arg) for arg in args)==1
How about this?
(not b and a) or (not a and b)
will give a if b is false
will give b if a is false
will give False otherwise
Or with the Python 2.5+ ternary expression:
(False if a else b) if b else a
It's easy when you know what XOR does:
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))
or: A or B: returns A if bool(A) is True, otherwise returns Band: A and B: returns A if bool(A) is False, otherwise returns BTo keep most of that way of thinking, my logical xor definintion would be:
def logical_xor(a, b):
if bool(a) == bool(b):
return False
else:
return a or b
That way it can return a, b, or False:
>>> logical_xor('this', 'that')
False
>>> logical_xor('', '')
False
>>> logical_xor('this', '')
'this'
>>> logical_xor('', 'that')
'that'
We can easily find xor of two variables by the using:
def xor(a,b):
return a !=b
Example:
xor(True,False) >>> True
The way that Python handles logic operations can be confusing, so my implementation gives the user the option (by default) of a simple True/False answer. The actual Python result can be obtained by setting the optional third arg to None.
def xor(a, b, true=True, false=False): # set true to None to get actual Python result
ab1 = a and not b
ab2 = not a and b
if bool(ab1) != bool(ab2):
return (ab1 or ab2) if true is None else true
else:
return false
As Zach explained, you can use:
xor = bool(a) ^ bool(b)
Personally, I favor a slightly different dialect:
xor = bool(a) + bool(b) == 1
This dialect is inspired from a logical diagramming language I learned in school where "OR" was denoted by a box containing =1 (greater than or equal to 1) and "XOR" was denoted by a box containing =1.
This has the advantage of correctly implementing exclusive or on multiple operands.
Simple, easy to understand:
sum(bool(a), bool(b)) == 1
If an exclusive choice is what you're after, i.e. to select 1 choice out of n, it can be expanded to multiple arguments:
sum(bool(x) for x in y) == 1
Source: Stackoverflow.com