Gibt es eine elegantere Möglichkeit, ((x == a und y == b) oder (x == b und y == a)) auszudrücken?

Ich versuche ((x == a and y == b) or (x == b and y == a))in Python zu evaluieren , aber es scheint ein bisschen ausführlich zu sein. Gibt es einen eleganteren Weg?

Wenn die Elemente hashbar sind, können Sie Mengen verwenden:

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

Ich denke, das Beste, was Sie bekommen können, ist, sie in Tupel zu verpacken:

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

Oder wickeln Sie das in eine Set-Lookup ein

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

Gerade als es in einigen Kommentaren erwähnt wurde, habe ich einige Timings durchgeführt, und Tupel und Sets scheinen hier identisch zu sein, wenn die Suche fehlschlägt:

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

Obwohl Tupel tatsächlich schneller sind, wenn die Suche erfolgreich ist:

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

Ich habe mich für die Verwendung eines Sets entschieden, weil ich eine Mitgliedersuche durchführe, und konzeptionell passt ein Set besser zu diesem Anwendungsfall als ein Tupel. Wenn Sie in einem bestimmten Anwendungsfall einen signifikanten Unterschied zwischen den beiden Strukturen gemessen haben, wählen Sie die schnellere. Ich denke jedoch nicht, dass Leistung hier ein Faktor ist.

Tupel machen es etwas lesbarer:

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

Dies gibt einen Hinweis: Wir prüfen, ob die Sequenz x, yder Sequenz entspricht a, b, ignorieren jedoch die Reihenfolge. Das ist nur Gleichheit!

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

Wenn die Elemente nicht hashbar sind, aber Bestellvergleiche unterstützen, können Sie Folgendes versuchen:

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

Der eleganteste Weg wäre meiner Meinung nach

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

Dies ist ein besserer Weg als die Verwendung von Mengen, dh {a, b} == {y, x}wie in anderen Antworten angegeben, da wir nicht darüber nachdenken müssen, ob die Variablen hashbar sind.

Wenn dies Zahlen sind, können Sie verwenden (x+y)==(a+b) and (x*y)==(a*b).

Wenn dies vergleichbare Artikel sind, können Sie verwenden min(x,y)==min(a,b) and max(x,y)==max(a,b).

Ist ((x == a and y == b) or (x == b and y == a))aber klar, sicher und allgemeiner.

Als Verallgemeinerung auf mehr als zwei Variablen können wir verwenden itertools.permutations. Das ist statt

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

wir können schreiben

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

Und natürlich die zwei variablen Versionen:

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

Sie können Tupel verwenden, um Ihre Daten darzustellen, und dann prüfen, ob sie festgelegt sind, z.

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

    return (x, y) in test_set

Sie haben bereits die am besten lesbare Lösung . Es gibt andere Möglichkeiten, dies auszudrücken, vielleicht mit weniger Zeichen, aber sie sind weniger einfach zu lesen.

Abhängig davon, was die Werte tatsächlich darstellen, ist es am besten, den Scheck in eine Funktion mit einem sprechenden Namen einzuwickeln . Alternativ oder zusätzlich können Sie die Objekte x, y und a, b jeweils in dedizierten Objekten höherer Klasse modellieren, die Sie dann mit der Logik des Vergleichs in einer Methode zur Überprüfung der Klassengleichheit oder einer dedizierten benutzerdefinierten Funktion vergleichen können.

Es scheint, dass sich das OP nur mit dem Fall von zwei Variablen befasst hat, aber da StackOverflow auch für diejenigen gedacht ist, die später nach derselben Frage suchen, werde ich versuchen, den allgemeinen Fall hier etwas detaillierter zu behandeln. Eine vorherige Antwort enthält bereits eine generische Antwort mit itertools.permutations(), aber diese Methode führt zu O(N*N!)Vergleichen, da es N!Permutationen mit jeweils NElementen gibt. (Dies war die Hauptmotivation für diese Antwort)

Lassen Sie uns zunächst zusammenfassen, wie einige der Methoden in früheren Antworten auf den generischen Fall als Motivation für die hier vorgestellte Methode zutreffen. Ich werde verwenden, um auf Azu verweisen (x, y)und auf Bzu verweisen (a, b), was Tupel beliebiger (aber gleicher) Länge sein können.

set(A) == set(B)ist schnell, funktioniert aber nur, wenn die Werte hashbar sind und Sie garantieren können, dass eines der Tupel keine doppelten Werte enthält. (ZB {1, 1, 2} == {1, 2, 2}wie von @ user2357112 unter @ Daniel Mesejos Antwort hervorgehoben)

Die vorherige Methode kann erweitert werden, um mit doppelten Werten zu arbeiten, indem Wörterbücher mit Zählungen anstelle von Mengen verwendet werden: (Dies hat immer noch die Einschränkung, dass alle Werte hashbar sein müssen, z. B. veränderbare Werte wie listfunktionieren nicht.)

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)erfordert keine hashbaren Werte, ist jedoch etwas langsamer und erfordert stattdessen bestellbare Werte. (Also zB complexnicht funktionieren)

A in itertools.permutations(B)Es sind keine hashbaren oder bestellbaren Werte erforderlich, aber wie bereits erwähnt, ist es komplex O(N*N!), sodass selbst bei nur 11 Elementen die Fertigstellung über eine Sekunde dauern kann.

Gibt es also eine Möglichkeit, so allgemein zu sein, aber geht es erheblich schneller? Warum ja, indem "manuell" überprüft wird, ob von jedem Element die gleiche Menge vorhanden ist: (Die Komplexität dieses Elements ist O(N^2)so, dass dies auch für große Eingaben nicht gut ist. Auf meinem Computer können 10.000 Elemente eine Sekunde dauern - aber mit kleinere Eingaben, wie 10 Elemente, dies ist genauso schnell wie die anderen)

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

Um die beste Leistung zu erzielen, sollten Sie dictzuerst die sortedMethode -based ausprobieren, auf die -based-Methode zurückgreifen, wenn dies aufgrund nicht zerlegbarer Werte fehlschlägt, und schließlich auf die count-based-Methode zurückgreifen, wenn auch dies aufgrund nicht ordnbarer Werte fehlschlägt.