Чи є більш елегантний спосіб виразити ((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 кожен із виділених об'єктів вищого класу, які ви потім можете порівняти з логікою порівняння методом перевірки рівності класів або виділеною спеціальною функцією.

Здається, що ОП стосувався лише випадку двох змінних, але оскільки 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-base, повернутися до countметоду -abased, якщо це не вдається через незмінні значення, і, нарешті, повернутися до методу-base, якщо це занадто не вдається через нерозбірливі значення.