我正在尝试在Python中评估((x == a and y == b) or (x == b and y == a))，但它似乎有点冗长。还有比这更优雅的方式吗？
如果元素是可哈希的，则可以使用集合：
{a, b} == {y, x}
我认为你能得到的最好的就是将它们打包成元组：
if (a, b) == (x, y) or (a, b) == (y, x)
或者，也许将其包装在集合查找中
if (a, b) in {(x, y), (y, x)}
自从几条评论提到它以来，我做了一些计时，当查找失败时，元组和集合在这里似乎表现相同：
from timeit import timeit
x = 1
y = 2
a = 3
b = 4
>>> timeit(lambda: (a, b) in {(x, y), (y, x)}, number=int(5e7))
32.8357742
>>> timeit(lambda: (a, b) in ((x, y), (y, x)), number=int(5e7))
31.6169182
尽管当查找成功时，元组实际上更快：
x = 1
y = 2
a = 1
b = 2
>>> timeit(lambda: (a, b) in {(x, y), (y, x)}, number=int(5e7))
35.6219458
>>> timeit(lambda: (a, b) in ((x, y), (y, x)), number=int(5e7))
27.753138700000008
我选择使用集合是因为我正在进行成员资格查找，从概念上讲，集合比元组更适合该用例。如果您在特定用例中测量了两种结构之间的显着差异，请使用更快的结构。不过，我不认为性能是一个因素。
>元组使其更具可读性：
(x, y) == (a, b) or (x, y) == (b, a)
这给出了一个线索：我们正在检查序列x, y是否等于序列a, b但忽略排序。那只是设定平等！
{x, y} == {a, b}
如果项目不可哈希处理，但支持排序比较，则可以尝试：
sorted((x, y)) == sorted((a, b))
在我看来，最优雅的方式是
(x, y) in ((a, b), (b, a))
这是比使用集合更好的方法，即{a, b} == {y, x}，如其他答案所示，因为我们不需要考虑变量是否可哈希。
如果这些是数字，您可以使用(x+y)==(a+b) and (x*y)==(a*b).
如果这些是可比较的项目，则可以使用min(x,y)==min(a,b) and max(x,y)==max(a,b).
但((x == a and y == b) or (x == b and y == a))是清晰、安全和更普遍的。
作为对两个以上变量的推广，我们可以使用itertools.permutations.而不是
(x == a and y == b and z == c) or (x == a and y == c and z == b) or ...
我们可以写
(x, y, z) in itertools.permutations([a, b, c])
当然还有两个变量版本：
(x, y) in itertools.permutations([a, b])
您可以使用元组来表示数据，然后检查集合包含，例如：
def test_fun(x, y):
test_set = {(a, b), (b, a)}
return (x, y) in test_set
您已经得到了最易读的解决方案。还有其他方法可以表达这一点，也许字符更少，但它们不那么直接阅读。
根据值实际表示的内容，最好的办法是将检查包装在具有说话名称的函数中。或者，或者此外，您可以在专用的更高类对象中分别对对象 x，y 和 a，b 进行建模，然后可以将其与类相等性检查方法或专用自定义函数中的比较逻辑进行比较。
OP 似乎只关注两个变量的情况，但由于 StackOverflow 也适用于那些稍后搜索相同问题的人，我将尝试在这里详细处理通用情况;前面的一个答案已经包含一个使用itertools.permutations()的通用答案，但这种方法会导致O(N*N!)比较，因为每个都有N项的N!排列。(这是这个答案的主要动机(
首先，让我们总结一下前面答案中的一些方法如何适用于一般情况，作为这里介绍的方法的动机。我将使用A来指代(x, y)，B来指代(a, b)，它可以是任意(但相等(长度的元组。
set(A) == set(B)速度很快，但仅当值可哈希且可以保证其中一个元组不包含任何重复值时才有效。(例如。{1, 1, 2} == {1, 2, 2}，正如@user2357112在@Daniel Mesejo的回答下指出的那样(
前面的方法可以通过使用带有计数的字典而不是集合来扩展为处理重复值：(这仍然具有所有值都需要可哈希的限制，因此例如像list这样的可变值将不起作用(
def counts(items):
d = {}
for item in items:
d[item] = d.get(item, 0) + 1
return d
counts(A) == counts(B)
sorted(A) == sorted(B)不需要可哈希值，但速度稍慢，需要可排序的值。(例如complex行不通(
A in itertools.permutations(B)不需要可哈希或可排序的值，但如前所述，它具有O(N*N!)的复杂性，因此即使只有 11 个项目，也可能需要一秒钟才能完成。
那么，有没有办法像一般一样，但要快得多？为什么是，通过"手动"检查每个项目的数量是否相同：(这个的复杂性是O(N^2)，所以这也不适合大输入;在我的机器上，10k 个项目可能需要一秒钟 - 但对于较小的输入，例如 10 个项目，这与其他项目一样快(
def unordered_eq(A, B):
for a in A:
if A.count(a) != B.count(a):
return False
return True
为了获得最佳性能，可能需要先尝试基于dict的方法，如果由于不可哈希值而失败，则回退到基于sorted的方法，如果该方法也由于不可排序的值而失败，则最后回退到基于count的方法。