Apakah ada cara yang lebih elegan untuk mengekspresikan ((x == a dan y == b) atau (x == b dan y == a))?

Saya mencoba untuk mengevaluasi ((x == a and y == b) or (x == b and y == a))dengan Python, tetapi sepertinya agak bertele-tele. Apakah ada cara yang lebih elegan?

Jika elemen hashable, Anda bisa menggunakan set:

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

Saya pikir yang terbaik yang bisa Anda dapatkan adalah mengemasnya menjadi tupel:

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

Atau, mungkin membungkusnya dalam satu set pencarian

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

Hanya karena disebutkan oleh beberapa komentar, saya melakukan beberapa pengaturan waktu, dan tupel dan set muncul untuk tampil secara identik di sini ketika pencarian gagal:

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

Meskipun tuple sebenarnya lebih cepat ketika pencarian berhasil:

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

Saya memilih untuk menggunakan set karena saya sedang melakukan pencarian keanggotaan, dan secara konseptual satu set lebih cocok untuk case-use daripada tuple. Jika Anda mengukur perbedaan yang signifikan antara kedua struktur dalam use case tertentu, gunakan yang lebih cepat. Saya tidak berpikir kinerja adalah faktor di sini.

Tuples membuatnya sedikit lebih mudah dibaca:

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

Ini memberikan petunjuk: kami memeriksa apakah urutannya x, ysama dengan urutannya a, btetapi mengabaikan pemesanan. Itu hanya menetapkan kesetaraan!

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

Jika item tidak hashable, tetapi mendukung perbandingan pemesanan, Anda dapat mencoba:

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

Cara yang paling elegan, menurut saya, adalah

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

Ini adalah cara yang lebih baik daripada menggunakan set, yaitu {a, b} == {y, x}, seperti ditunjukkan dalam jawaban lain karena kita tidak perlu berpikir jika variabel-variabel tersebut dapat di hashable.

Jika ini angka, Anda bisa menggunakannya (x+y)==(a+b) and (x*y)==(a*b).

Jika ini adalah barang yang sebanding, Anda bisa menggunakannya min(x,y)==min(a,b) and max(x,y)==max(a,b).

Tetapi ((x == a and y == b) or (x == b and y == a))jelas, aman, dan lebih umum.

Sebagai generalisasi untuk lebih dari dua variabel yang bisa kita gunakan itertools.permutations. Itu bukan

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

kita bisa menulis

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

Dan tentu saja dua versi variabel:

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

Anda dapat menggunakan tupel untuk mewakili data Anda dan kemudian memeriksa set inklusi, seperti:

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

    return (x, y) in test_set

Anda sudah mendapatkan solusi yang paling mudah dibaca . Ada cara lain untuk mengekspresikan ini, mungkin dengan karakter yang lebih sedikit, tetapi mereka kurang mudah dibaca.

Bergantung pada nilai yang benar-benar mewakili taruhan terbaik Anda adalah untuk membungkus cek dalam fungsi dengan nama yang berbicara . Sebagai alternatif atau tambahan, Anda dapat memodelkan objek x, y dan a, b masing-masing dalam objek kelas tinggi khusus yang kemudian dapat Anda bandingkan dengan logika perbandingan dalam metode pemeriksaan kesetaraan kelas atau fungsi kustom khusus.

Tampaknya OP hanya peduli dengan kasus dua variabel, tetapi karena StackOverflow juga untuk mereka yang mencari pertanyaan yang sama nanti, saya akan mencoba untuk menangani kasus generik di sini secara rinci; Satu jawaban sebelumnya sudah menggunakan jawaban umum itertools.permutations(), tetapi metode itu mengarah ke O(N*N!)perbandingan, karena masing-masing ada N!permutasi dengan Nitem. (Ini adalah motivasi utama untuk jawaban ini)

Pertama, mari kita simpulkan bagaimana beberapa metode dalam jawaban sebelumnya berlaku untuk kasus umum, sebagai motivasi untuk metode yang disajikan di sini. Saya akan menggunakan Auntuk merujuk (x, y)dan Bmerujuk (a, b), yang bisa berupa tupel dengan panjang yang sewenang-wenang (tapi sama).

set(A) == set(B)cepat, tetapi hanya berfungsi jika nilainya hashable dan Anda dapat menjamin bahwa salah satu tupel tidak mengandung nilai duplikat apa pun. (Mis. {1, 1, 2} == {1, 2, 2}, Seperti yang ditunjukkan oleh @ user2357112 di bawah jawaban @Daniel Mesejo)

Metode sebelumnya dapat diperluas untuk bekerja dengan nilai duplikat dengan menggunakan kamus dengan jumlah, alih-alih set: (Ini masih memiliki batasan bahwa semua nilai harus dapat hashable, jadi mis. Nilai yang dapat diubah seperti listtidak akan berfungsi)

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)tidak memerlukan nilai hashable, tetapi sedikit lebih lambat, dan sebaliknya membutuhkan nilai yang bisa dipesan. (Jadi mis. Tidak complexakan bekerja)

A in itertools.permutations(B)tidak memerlukan nilai hashable atau orderable, tetapi seperti yang telah disebutkan, ia memiliki O(N*N!)kompleksitas, sehingga bahkan dengan hanya 11 item, dapat membutuhkan waktu lebih dari satu detik untuk menyelesaikannya.

Jadi, apakah ada cara untuk menjadi umum, tetapi apakah itu jauh lebih cepat? Mengapa ya, dengan "secara manual" memeriksa bahwa ada jumlah yang sama dari setiap item: (Kompleksitas yang satu ini O(N^2), jadi ini juga tidak baik untuk input besar; Pada mesin saya, 10k item dapat membutuhkan waktu satu detik - tetapi dengan input yang lebih kecil, seperti 10 item, ini sama cepatnya dengan yang lain)

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

Untuk mendapatkan kinerja terbaik, orang mungkin ingin mencoba dictmetode berbasis pertama, kembali ke sortedmetode berbasis jika itu gagal karena nilai-nilai yang tidak dapat dihancurkan, dan akhirnya jatuh kembali ke countmetode berbasis jika itu juga gagal karena nilai-nilai tidak teratur.