Existe uma maneira mais elegante de expressar ((x == a e y == b) ou (x == b e y == a))?

Estou tentando avaliar ((x == a and y == b) or (x == b and y == a))em Python, mas parece um pouco detalhado. Existe uma maneira mais elegante?

Se os elementos forem laváveis, você poderá usar conjuntos:

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

Eu acho que o melhor que você pode obter é empacotá-los em tuplas:

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

Ou talvez envolva isso em uma pesquisa definida

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

Desde que foi mencionado por alguns comentários, fiz alguns intervalos e tuplas e conjuntos parecem ter um desempenho idêntico aqui quando a pesquisa falha:

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

Embora as tuplas sejam realmente mais rápidas quando a pesquisa for bem-sucedida:

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

Eu escolhi usar um conjunto porque estou fazendo uma pesquisa de associação e, conceitualmente, um conjunto é mais adequado para esse caso de uso do que uma tupla. Se você mediu uma diferença significativa entre as duas estruturas em um caso de uso específico, siga a mais rápida. Não acho que o desempenho seja um fator aqui.

As tuplas o tornam um pouco mais legível:

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

Isso dá uma pista: estamos verificando se a sequência x, yé igual à sequência, a, bmas ignorando a ordem. Isso é apenas definir a igualdade!

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

Se os itens não forem editáveis, mas suportarem comparações de pedidos, você pode tentar:

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

A maneira mais elegante, na minha opinião, seria

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

Essa é uma maneira melhor do que usar conjuntos, ou seja {a, b} == {y, x}, conforme indicado em outras respostas, porque não precisamos pensar se as variáveis ​​são hashable.

Se estes são números, você pode usar (x+y)==(a+b) and (x*y)==(a*b).

Se esses itens são comparáveis, você pode usar min(x,y)==min(a,b) and max(x,y)==max(a,b).

Mas ((x == a and y == b) or (x == b and y == a))é claro, seguro e mais geral.

Como generalização para mais de duas variáveis, podemos usar itertools.permutations. Isso é em vez de

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

nós podemos escrever

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

E, claro, a versão de duas variáveis:

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

Você pode usar tuplas para representar seus dados e verificar a inclusão de conjuntos, como:

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

    return (x, y) in test_set

Você já tem a solução mais legível . Existem outras maneiras de expressar isso, talvez com menos caracteres, mas são menos fáceis de ler.

Dependendo do que os valores realmente representam, sua melhor aposta é encerrar o cheque em uma função com um nome falante . Como alternativa ou além disso, é possível modelar os objetos x, ye a, b, cada um em objetos dedicados de classe superior, que você poderá comparar com a lógica da comparação em um método de verificação de igualdade de classe ou em uma função personalizada dedicada.

Parece que o OP estava preocupado apenas com o caso de duas variáveis, mas como o StackOverflow também é para quem procurar a mesma pergunta posteriormente, tentarei abordar o caso genérico aqui com mais detalhes; Uma resposta anterior já contém uma resposta genérica usando itertools.permutations(), mas esse método leva a O(N*N!)comparações, pois existem N!permutações com Nitens cada. (Essa foi a principal motivação para esta resposta)

Primeiro, vamos resumir como alguns dos métodos das respostas anteriores se aplicam ao caso genérico, como motivação para o método apresentado aqui. Vou usar Apara me referir (x, y)e Bme referir (a, b), que podem ser tuplas de comprimento arbitrário (mas igual).

set(A) == set(B)é rápido, mas só funciona se os valores forem hasháveis ​​e você pode garantir que uma das tuplas não contenha valores duplicados. (Por exemplo {1, 1, 2} == {1, 2, 2}, como apontado por @ user2357112 na resposta de @Daniel Mesejo)

O método anterior pode ser estendido para trabalhar com valores duplicados usando dicionários com contagens, em vez de conjuntos: (Isso ainda tem a limitação de que todos os valores precisam ser laváveis, portanto, por exemplo, valores mutáveis ​​como listnão funcionarão)

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)não requer valores laváveis, mas é um pouco mais lento e requer valores ordenáveis. (Então, por exemplo complex, não funcionará)

A in itertools.permutations(B)não requer valores laváveis ​​ou ordenáveis, mas, como já mencionado, possui O(N*N!)complexidade; portanto, mesmo com apenas 11 itens, pode demorar um segundo para terminar.

Então, existe uma maneira de ser tão geral, mas é consideravelmente mais rápido? Por que sim, verificando "manualmente" se existe a mesma quantidade de cada item: (A complexidade deste é O(N^2), portanto, também não é bom para entradas grandes; na minha máquina, 10 mil itens podem demorar um segundo - mas com entradas menores, como 10 itens, isso é tão rápido quanto os outros)

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

Para obter o melhor desempenho, pode-se tentar dictprimeiro o método baseado em, retornar ao sortedmétodo baseado em falha devido a valores laváveis ​​e, finalmente, voltar ao countmétodo baseado em falha também devido a valores desordenados.