Có cách nào thanh lịch hơn để thể hiện ((x == a và y == b) hoặc (x == b và y == a))?

Tôi đang cố gắng đánh giá ((x == a and y == b) or (x == b and y == a))bằng Python, nhưng có vẻ hơi dài dòng. Có cách nào thanh lịch hơn?

Nếu các yếu tố có thể băm, bạn có thể sử dụng các bộ:

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

Tôi nghĩ rằng điều tốt nhất bạn có thể nhận được là gói chúng thành các bộ dữ liệu:

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

Hoặc, có thể gói nó trong một tra cứu thiết lập

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

Ngay khi nó được đề cập bởi một vài bình luận, tôi đã thực hiện một số thời gian, và các bộ và bộ dường như thực hiện giống hệt ở đây khi việc tra cứu thất bại:

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

Mặc dù bộ dữ liệu thực sự nhanh hơn khi tra cứu thành công:

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

Tôi đã chọn sử dụng một bộ vì tôi đang thực hiện tra cứu thành viên và về mặt khái niệm, một bộ phù hợp hơn cho trường hợp sử dụng đó hơn là một tuple. Nếu bạn đo một sự khác biệt đáng kể giữa hai cấu trúc trong một trường hợp sử dụng cụ thể, hãy đi với cấu trúc nhanh hơn. Tôi không nghĩ rằng hiệu suất là một yếu tố ở đây mặc dù.

Tuples làm cho nó dễ đọc hơn một chút:

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

Điều này cho một manh mối: chúng tôi đang kiểm tra xem chuỗi x, ycó bằng chuỗi hay không a, bmà bỏ qua thứ tự. Đó chỉ là thiết lập bình đẳng!

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

Nếu các mục không thể băm, nhưng hỗ trợ so sánh đặt hàng, bạn có thể thử:

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

Cách thanh lịch nhất, theo tôi, sẽ là

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

Đây là một cách tốt hơn so với sử dụng các tập hợp, {a, b} == {y, x}như được chỉ ra trong các câu trả lời khác bởi vì chúng ta không cần phải suy nghĩ nếu các biến có thể băm được.

Nếu đây là những con số, bạn có thể sử dụng (x+y)==(a+b) and (x*y)==(a*b).

Nếu đây là những mặt hàng tương đương, bạn có thể sử dụng min(x,y)==min(a,b) and max(x,y)==max(a,b).

Nhưng ((x == a and y == b) or (x == b and y == a))là rõ ràng, an toàn, và tổng quát hơn.

Là một khái quát cho hơn hai biến chúng ta có thể sử dụng itertools.permutations. Đó là thay vì

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

chúng tôi có thể viết

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

Và tất nhiên hai phiên bản biến:

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

Bạn có thể sử dụng các bộ dữ liệu để thể hiện dữ liệu của mình và sau đó kiểm tra để bao gồm thiết lập, như:

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

    return (x, y) in test_set

Bạn đã có giải pháp dễ đọc nhất . Có nhiều cách khác để diễn đạt điều này, có lẽ với ít ký tự hơn, nhưng chúng ít thẳng thắn hơn để đọc.

Tùy thuộc vào những gì các giá trị thực sự đại diện cho đặt cược tốt nhất của bạn là bọc séc trong một chức năng bằng một tên nói . Ngoài ra, ngoài ra, bạn có thể mô hình hóa các đối tượng x, y và a, b trong các đối tượng lớp chuyên dụng cao hơn mà sau đó bạn có thể so sánh với logic so sánh trong phương thức kiểm tra đẳng thức lớp hoặc hàm tùy chỉnh chuyên dụng.

Có vẻ như OP chỉ quan tâm đến trường hợp của hai biến, nhưng vì StackOverflow cũng dành cho những người tìm kiếm cùng một câu hỏi sau đó, tôi sẽ cố gắng giải quyết trường hợp chung ở đây một cách chi tiết; Một câu trả lời trước đã có câu trả lời chung chung bằng cách sử dụng itertools.permutations(), nhưng phương pháp đó dẫn đến O(N*N!)so sánh, vì có N!hoán vị vớiN các mục. (Đây là động lực chính cho câu trả lời này)

Trước tiên, hãy tóm tắt làm thế nào một số phương pháp trong các câu trả lời trước áp dụng cho trường hợp chung, như là động lực cho phương pháp được trình bày ở đây. Tôi sẽ sử dụng Ađể tham khảo (x, y)và Btham khảo(a, b) , có thể là các bộ dữ liệu có độ dài tùy ý (nhưng bằng nhau).

set(A) == set(B)là nhanh, nhưng chỉ hoạt động nếu các giá trị có thể băm và bạn có thể đảm bảo rằng một trong các bộ dữ liệu không chứa bất kỳ giá trị trùng lặp nào. (Ví dụ.{1, 1, 2} == {1, 2, 2} như được chỉ ra bởi @ user2357112 dưới câu trả lời của @Daniel Mesejo)

Phương thức trước có thể được mở rộng để hoạt động với các giá trị trùng lặp bằng cách sử dụng từ điển với số đếm, thay vì bộ: (Điều này vẫn có giới hạn là tất cả các giá trị cần phải được băm, ví dụ: các giá trị có thể thay đổi như listsẽ không hoạt động)

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)không yêu cầu giá trị có thể băm, nhưng chậm hơn một chút và thay vào đó yêu cầu giá trị có thể sắp xếp. (Vì vậy, ví dụ như complexsẽ không làm việc)

A in itertools.permutations(B)không yêu cầu các giá trị có thể băm hoặc có thể sắp xếp, nhưng như đã đề cập, nó có O(N*N!)độ phức tạp, vì vậy ngay cả chỉ với 11 mục, nó có thể mất hơn một giây để hoàn thành.

Vì vậy, có cách nào để chung chung, nhưng làm nó nhanh hơn đáng kể? Tại sao có, bằng cách "kiểm tra" thủ công rằng có cùng số lượng của từng mặt hàng: (Độ phức tạp của mặt hàng này là O(N^2), vì vậy điều này cũng không tốt cho đầu vào lớn; Trên máy của tôi, 10k mặt hàng có thể chiếm một giây - nhưng với đầu vào nhỏ hơn, như 10 mục, điều này cũng nhanh như các mục khác)

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

Để có được hiệu suất tốt nhất, trước tiên, người ta có thể muốn thử dictphương thức dựa trên cơ sở, quay lại sortedphương thức dựa trên cơ sở nếu điều đó không thành công do các giá trị không thể thực hiện được và cuối cùng quay lại countphương thức dựa trên cơ sở nếu quá thất bại do các giá trị không thể sắp xếp được.