Esiste un modo più elegante per esprimere ((x == a e y == b) o (x == b and y == a))?

Sto provando a valutare ((x == a and y == b) or (x == b and y == a))in Python, ma sembra un po 'prolisso. C'è un modo più elegante?

Se gli elementi sono hash, è possibile utilizzare i set:

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

Penso che il meglio che puoi ottenere sia impacchettarli in tuple:

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

O forse avvolgerlo in una ricerca set

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

Proprio da quando è stato menzionato da un paio di commenti, ho fatto dei tempi e tuple e set sembrano funzionare identicamente qui quando la ricerca fallisce:

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

Sebbene le tuple siano effettivamente più veloci quando la ricerca ha esito positivo:

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

Ho scelto di utilizzare un set perché sto effettuando una ricerca di appartenenza e concettualmente un set è più adatto a quel caso d'uso rispetto a una tupla. Se hai misurato una differenza significativa tra le due strutture in un caso d'uso particolare, scegli quella più veloce. Non penso che le prestazioni siano un fattore qui.

Le tuple lo rendono leggermente più leggibile:

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

Questo dà un indizio: stiamo verificando se la sequenza x, yè uguale alla sequenza a, bma ignoriamo l'ordinamento. Questo è solo set uguaglianza!

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

Se gli articoli non sono hash, ma supportano il confronto degli ordini, puoi provare:

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

Il modo più elegante, secondo me, sarebbe

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

Questo è un modo migliore rispetto all'utilizzo dei set, ovvero {a, b} == {y, x}come indicato in altre risposte perché non abbiamo bisogno di pensare se le variabili sono hash.

Se questi sono numeri, puoi usare (x+y)==(a+b) and (x*y)==(a*b).

Se si tratta di articoli comparabili, è possibile utilizzare min(x,y)==min(a,b) and max(x,y)==max(a,b).

Ma ((x == a and y == b) or (x == b and y == a))è chiaro, sicuro e più generale.

Come generalizzazione per più di due variabili possiamo usare itertools.permutations. Questo è invece di

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

possiamo scrivere

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

E ovviamente le due versioni variabili:

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

Puoi utilizzare le tuple per rappresentare i tuoi dati e quindi verificare l'inserimento impostato, come:

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

    return (x, y) in test_set

Hai già la soluzione più leggibile . Esistono altri modi per esprimerlo, forse con meno personaggi, ma sono meno semplici da leggere.

A seconda di ciò che i valori rappresentano effettivamente la tua scommessa migliore è racchiudere il controllo in una funzione con un nome parlato . In alternativa o in aggiunta, è possibile modellare gli oggetti x, y e a, b ciascuno in oggetti di classe superiore dedicati che è quindi possibile confrontare con la logica del confronto in un metodo di controllo dell'uguaglianza di classe o in una funzione personalizzata dedicata.

Sembra che l'OP si occupasse solo del caso di due variabili, ma poiché StackOverflow è anche per coloro che cercano la stessa domanda in seguito, proverò ad affrontare il caso generico qui in dettaglio; Una risposta precedente contiene già una risposta generica usando itertools.permutations(), ma quel metodo porta a O(N*N!)confronti, poiché ci sono N!permutazioni con Nelementi ciascuno. (Questa è stata la motivazione principale per questa risposta)

Innanzitutto, riassumiamo come alcuni dei metodi delle risposte precedenti si applicano al caso generico, come motivazione per il metodo presentato qui. Userò Aper fare riferimento (x, y)e Bfare riferimento a (a, b), che può essere tuple di lunghezza arbitraria (ma uguale).

set(A) == set(B)è veloce, ma funziona solo se i valori sono hash e puoi garantire che una delle tuple non contenga valori duplicati. (Ad esempio {1, 1, 2} == {1, 2, 2}, come sottolineato da @ user2357112 nella risposta di @Daniel Mesejo)

Il metodo precedente può essere esteso per funzionare con valori duplicati usando dizionari con conteggi, anziché set: (Questo ha ancora la limitazione che tutti i valori devono essere hash, quindi ad esempio valori mutabili come listnon funzioneranno)

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)non richiede valori hash, ma è leggermente più lento e richiede invece valori ordinabili. (Quindi ad es. complexNon funzionerà)

A in itertools.permutations(B)non richiede valori hash o ordinabili, ma come già accennato, ha O(N*N!)complessità, quindi anche con solo 11 articoli, può richiedere più di un secondo per terminare.

Quindi, c'è un modo per essere il più generale, ma lo fa considerevolmente più veloce? Perché sì, controllando "manualmente" che c'è la stessa quantità di ogni articolo: (La complessità di questo è O(N^2), quindi non va bene nemmeno per input di grandi dimensioni; Sulla mia macchina, 10k articoli possono richiedere un secondo, ma con input più piccoli, come 10 elementi, questo è veloce come gli altri)

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

Per ottenere le migliori prestazioni, si potrebbe desiderare di provare dictprima il metodo basato su, tornare al sortedmetodo basato su se ciò fallisce a causa di valori non lavabili, e infine ritornare al countmetodo basato su se anche quello fallisce a causa di valori non ordinabili.