Czy istnieje bardziej elegancki sposób wyrażenia ((x == ay y == b) lub (x == bi y == a))?

Próbuję oceniać ((x == a and y == b) or (x == b and y == a))w Pythonie, ale wydaje się to trochę gadatliwe. Czy istnieje bardziej elegancki sposób?

Jeśli elementy są haszowalne, możesz użyć zestawów:

{a, b} == {y, x}

Myślę, że najlepsze, co możesz dostać, to spakować je w krotki:

if (a, b) == (x, y) or (a, b) == (y, x)

A może zawiń to w zestaw wyszukiwania

if (a, b) in {(x, y), (y, x)}

Właśnie dlatego, że zostało to wspomniane w kilku komentarzach, zrobiłem pewne czasy, a krotki i zestawy wydają się działać tutaj identycznie, gdy wyszukiwanie nie powiedzie się:

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

Chociaż krotki są w rzeczywistości szybsze, gdy wyszukiwanie się powiedzie:

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

Zdecydowałem się użyć zestawu, ponieważ przeprowadzam wyszukiwanie członkostwa, a koncepcyjnie zestaw lepiej pasuje do tego przypadku użycia niż krotka. Jeśli zmierzyłeś znaczącą różnicę między dwiema strukturami w konkretnym przypadku użycia, przejdź do szybszej. Nie sądzę jednak, żeby wydajność była tutaj czynnikiem.

Krotki sprawiają, że jest nieco bardziej czytelny:

(x, y) == (a, b) or (x, y) == (b, a)

To daje wskazówkę: sprawdzamy, czy sekwencja x, yjest równa sekwencji, a, bale ignorujemy kolejność. To tylko równość!

{x, y} == {a, b}

Jeśli elementy nie są haszowalne, ale obsługują porównywanie zamówień, możesz spróbować:

sorted((x, y)) == sorted((a, b))

Moim zdaniem byłby to najbardziej elegancki sposób

(x, y) in ((a, b), (b, a))

Jest to lepszy sposób niż używanie zbiorów, tj. {a, b} == {y, x}Jak wskazano w innych odpowiedziach, ponieważ nie musimy myśleć, czy zmienne są możliwe do skrócenia.

Jeśli są to liczby, możesz użyć (x+y)==(a+b) and (x*y)==(a*b) .

Jeśli są to porównywalne przedmioty, możesz użyć min(x,y)==min(a,b) and max(x,y)==max(a,b) .

Ale ((x == a and y == b) or (x == b and y == a))jest jasne, bezpieczne i bardziej ogólne.

Jako uogólnienie na więcej niż dwie zmienne możemy użyć itertools.permutations. To jest zamiast

(x == a and y == b and z == c) or (x == a and y == c and z == b) or ...

możemy pisać

(x, y, z) in itertools.permutations([a, b, c])

I oczywiście dwie zmienne wersje:

(x, y) in itertools.permutations([a, b])

Możesz użyć krotek do przedstawienia swoich danych, a następnie sprawdzić włączenie zestawu, na przykład:

def test_fun(x, y):
    test_set = {(a, b), (b, a)}

    return (x, y) in test_set

Masz już najbardziej czytelne rozwiązanie . Istnieją inne sposoby wyrażenia tego, być może przy użyciu mniejszej liczby znaków, ale są one mniej czytelne.

W zależności od tego, jakie wartości faktycznie reprezentują twój najlepszy zakład, należy zawrzeć czek w funkcji wypowiedzianą nazwą . Alternatywnie lub dodatkowo można modelować obiekty x, y i a, b w dedykowanych obiektach wyższej klasy, które następnie można porównać z logiką porównania w metodzie sprawdzania równości klas lub dedykowanej funkcji niestandardowej.

Wygląda na to, że OP zajmował się jedynie przypadkiem dwóch zmiennych, ale ponieważ StackOverflow jest również dla tych, którzy szukają tego samego pytania później, postaram się tutaj szczegółowo zająć przypadkiem ogólnym; Jedna poprzednia odpowiedź zawiera już ogólną odpowiedź itertools.permutations(), ale ta metoda prowadzi do O(N*N!)porównań, ponieważ istnieją N!permutacje z Nelementami. (To była główna motywacja tej odpowiedzi)

Najpierw podsumujmy, w jaki sposób niektóre metody z poprzednich odpowiedzi odnoszą się do przypadku ogólnego, jako motywację do metody przedstawionej tutaj. Będę używać Ado odwoływania się (x, y)i Bdo odniesienia (a, b), które mogą być krotkami o dowolnej (ale równej) długości.

set(A) == set(B)jest szybki, ale działa tylko wtedy, gdy wartości są haszowalne i możesz zagwarantować, że jedna z krotek nie zawiera żadnych zduplikowanych wartości. (Na przykład.{1, 1, 2} == {1, 2, 2} , Jak wskazał @ user2357112 w odpowiedzi @Daniel Mesejo)

Poprzednia metoda może zostać rozszerzona do pracy ze zduplikowanymi wartościami za pomocą słowników z licznikami zamiast zestawów: (To wciąż ma ograniczenie, że wszystkie wartości muszą być możliwe do skrótu, więc np. Zmienne wartości takie jak listnie będą działać)

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)nie wymaga wartości mieszających, ale jest nieco wolniejszy i zamiast tego wymaga wartości uporządkowanych. (Więc np. complexNie będzie działać)

A in itertools.permutations(B)nie wymaga wartości skrótu ani zamówień, ale jak już wspomniano, ma O(N*N!)złożoność, więc nawet przy 11 elementach ukończenie może zająć sekundę.

Czy istnieje sposób, aby być tak ogólnym, ale czy jest to znacznie szybsze? Dlaczego tak, „ręcznie” sprawdzając, czy jest taka sama ilość każdego elementu: (Złożoność tego jest O(N^2)taka, że ​​nie jest to również dobre w przypadku dużych nakładów; na mojej maszynie 10 000 elementów może zająć sekundę - ale z mniejsze nakłady, takie jak 10 pozycji, jest tak samo szybki jak inne)

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

Aby uzyskać najlepszą wydajność, można dictnajpierw wypróbować metodę opartą na bazie , powrócić do sortedmetody opartej na bazie, jeśli to się nie powiedzie z powodu nieusuwalnych wartości, a na koniec wrócić do countmetody opartej na podstawie , jeśli to też się nie powiedzie z powodu nieuporządkowanych wartości.