((X == a ve y == b) veya (x == b ve y == a)) ifade etmenin daha zarif bir yolu var mı?

((x == a and y == b) or (x == b and y == a))Python'da değerlendirmeye çalışıyorum , ama biraz ayrıntılı görünüyor. Daha zarif bir yol var mı?

Elemanlar yıkanabilirse, setleri kullanabilirsiniz:

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

Bence alabileceğiniz en iyi şey onları tuples'e paketlemektir:

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

Ya da belki bunu bir set aramasına sarın

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

Birkaç yorumdan bahsedildiği için, bazı zamanlamalar yaptım ve arama başarısız olduğunda tuples ve setler aynı şekilde performans gösteriyor gibi görünüyor:

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

Arama başarılı olduğunda tuples aslında daha hızlı olsa da:

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

Bir set kullanmayı seçtim çünkü bir üyelik araması yapıyorum ve kavramsal olarak bir set bu kullanım senaryosu için bir demetten daha uygun. Belirli bir kullanım durumunda iki yapı arasında önemli bir fark ölçtüyseniz, daha hızlı olanı kullanın. Performansın burada bir faktör olduğunu düşünmüyorum.

Tuples biraz daha okunabilir hale getiriyor:

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

Bu bir ipucu verir: dizinin diziye x, yeşit olup olmadığını kontrol edip sıralamayı a, bgöz ardı ediyoruz . Bu sadece eşitlik!

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

Öğeler yıkanamazsa, ancak sipariş karşılaştırmalarını destekliyorsa, deneyebilirsiniz:

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

Bana göre en zarif yol,

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

Bu, kümeleri kullanmaktan daha iyi bir yoldur, yani {a, b} == {y, x}diğer cevaplarda belirtildiği gibi, değişkenlerin yıkanabilir olup olmadığını düşünmemize gerek yoktur.

Bunlar sayılarsa kullanabilirsiniz (x+y)==(a+b) and (x*y)==(a*b).

Bunlar karşılaştırılabilir öğelerse kullanabilirsiniz min(x,y)==min(a,b) and max(x,y)==max(a,b).

Ancak ((x == a and y == b) or (x == b and y == a))açık, güvenli ve daha geneldir.

İkiden fazla değişkene genelleme olarak kullanabiliriz itertools.permutations. Bunun yerine

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

yazabiliriz

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

Ve elbette iki değişkenli versiyon:

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

Verilerinizi temsil etmek için tuples kullanabilir ve ardından aşağıdakileri içeren set dahil etmeyi kontrol edebilirsiniz:

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

    return (x, y) in test_set

En okunabilir çözümü zaten aldınız . Bunu, belki de daha az karakterle ifade etmenin başka yolları da vardır, ancak bunları okumak daha az kolaydır.

Değerlerin gerçekte en iyi bahsinizi temsil ettiğine bağlı olarak , çek ismini konuşan bir isimle sarmaktır . Alternatif olarak veya ek olarak, x, y ve a, b nesnelerini, daha sonra bir sınıf eşitliği kontrol yönteminde veya özel bir özel işlevde karşılaştırmanın mantığı ile karşılaştırabileceğiniz özel yüksek sınıf nesnelerinde modelleyebilirsiniz.

OP sadece iki değişkenle ilgiliydi, ancak StackOverflow da aynı soruyu daha sonra arayanlar için olduğundan, genel durumu burada ayrıntılı olarak ele almaya çalışacağım; Önceki bir cevap zaten kullanarak genel bir cevap içerir itertools.permutations(), ancak her biri öğelerle permütasyonlar olduğu için bu yöntem O(N*N!)karşılaştırmaya yol açar . (Bu cevap için ana motivasyon buydu)N!N

İlk olarak, önceki yanıtlardaki yöntemlerden bazılarının burada sunulan yöntem için motivasyon olarak genel durum için nasıl geçerli olduğunu özetleyelim. I kullanarak olacak Aatıfta (x, y)ve Bifade etmek için (a, b)keyfi (fakat eşit) uzunluğunda küpe olabilir,.

set(A) == set(B)hızlıdır, ancak yalnızca değerlerin yıkanabilir olması durumunda çalışır ve gruplardan birinin yinelenen değerler içermediğini garanti edebilirsiniz. (Örn. {1, 1, 2} == {1, 2, 2}, @Daniel Mesejo'nun cevabı altında @ user2357112 tarafından belirtildiği gibi)

Önceki yöntem, kümeler yerine sayıları olan sözlükler kullanarak yinelenen değerlerle çalışmak üzere genişletilebilir: (Bu yine de tüm değerlerin yıkanabilir olması gibi bir sınırlamaya sahiptir, örn. Gibi değiştirilebilir değerler listçalışmaz)

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)yıkanabilir değerler gerektirmez, ancak biraz daha yavaştır ve bunun yerine düzenlenebilir değerler gerektirir. (Yani, örneğin complexçalışmaz)

A in itertools.permutations(B)yıkanabilir veya düzenlenebilir değerler gerektirmez, ancak daha önce de belirtildiği gibi, O(N*N!)karmaşıklığı vardır, bu nedenle sadece 11 öğeyle bile bitirmek bir saniyeyi alabilir.

Peki, genel olmanın bir yolu var, ama çok daha hızlı mı? Neden evet, "el ile" her öğenin aynı miktarda olup olmadığını kontrol ederek: (Bunun karmaşıklığı, bu O(N^2)büyük girişler için de iyi değil; Makinemde 10k öğe bir saniyeyi devralabilir - ancak 10 öğe gibi daha küçük girdiler, bu diğerleri kadar hızlıdır)

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

En iyi performansı elde etmek için, dictilk önce sorted-based yöntemini denemek, shahable değerleri nedeniyle başarısız olursa -based countyöntemine geri dönmek ve nihayetinde dayanılmaz değerler nedeniyle başarısız olursa -based yöntemine geri dönmek isteyebilirsiniz.