Есть ли более элегантный способ выражения ((x == a и y == b) или (x == b и y == a))?

Я пытаюсь оценить ((x == a and y == b) or (x == b and y == a))в Python, но это кажется немного многословным. Есть ли более элегантный способ?

Если элементы являются хэшируемыми, вы можете использовать наборы:

{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), что это также не хорошо для больших входов; на моей машине 10 тысяч элементов могут занять более секунды - но с меньшие входы, например 10 элементов, это так же быстро, как и другие)

def unordered_eq(A, B):
    for a in A:
        if A.count(a) != B.count(a):
            return False
    return True

Чтобы получить максимальную производительность, можно dictсначала попробовать метод sorted-based, вернуться к countметоду -base, если это не удастся из-за необратимых значений, и, наконец, вернуться к методу -based, если он тоже не удастся из-за неупорядоченных значений.