มีวิธีแสดงที่หรูหรากว่านี้ ((x == a และ y == b) หรือ (x == b และ y == a) หรือไม่

ฉันพยายามประเมิน((x == a and y == b) or (x == b and y == a))ด้วย Python แต่ดูเหมือนว่าจะค่อนข้างละเอียด มีวิธีที่สง่างามกว่านี้ไหม?

หากองค์ประกอบนั้น hashable คุณสามารถใช้ชุด:

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

ฉันคิดว่าสิ่งที่ดีที่สุดที่คุณจะทำได้คือบรรจุพวกมันไว้ในสิ่งอันดับ:

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

หรืออาจห่อในการค้นหาชุด

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

เนื่องจากมีการพูดถึงความคิดเห็นสองสามครั้งฉันจึงกำหนดเวลาไว้และ tuples และชุดปรากฏขึ้นเพื่อทำงานเหมือนกันที่นี่เมื่อการค้นหาล้มเหลว:

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

แม้ว่า tuples จะเร็วขึ้นจริงเมื่อค้นหาสำเร็จ:

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

ฉันเลือกที่จะใช้ชุดเพราะฉันทำการค้นหาความเป็นสมาชิกและแนวความคิดชุดที่เหมาะสำหรับกรณีการใช้งานที่ดีกว่า tuple หากคุณวัดความแตกต่างอย่างมีนัยสำคัญระหว่างโครงสร้างทั้งสองในกรณีการใช้งานเฉพาะให้ไปกับโครงสร้างที่เร็วกว่า ฉันไม่คิดว่าประสิทธิภาพเป็นปัจจัยที่นี่

สิ่งอันดับทำให้อ่านได้ง่ายขึ้นเล็กน้อย:

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

สิ่งนี้ให้เบาะแส: เรากำลังตรวจสอบว่าลำดับx, yมีค่าเท่ากับลำดับa, bแต่ไม่สนใจการสั่งซื้อหรือไม่ นั่นเป็นเพียงการตั้งค่าความเท่าเทียมกัน!

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

หากรายการไม่แฮช แต่ให้การสนับสนุนการเปรียบเทียบการสั่งซื้อคุณสามารถลอง:

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

วิธีที่หรูหราที่สุดในความคิดของฉันคือ

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

นี่เป็นวิธีที่ดีกว่าการใช้เซตเช่น{a, b} == {y, x}ตามที่ระบุในคำตอบอื่น ๆ เพราะเราไม่จำเป็นต้องคิดว่าตัวแปรนั้นมีแฮช

(x+y)==(a+b) and (x*y)==(a*b)ถ้าสิ่งเหล่านี้เป็นตัวเลขที่คุณสามารถใช้

min(x,y)==min(a,b) and max(x,y)==max(a,b)ถ้าสิ่งเหล่านี้เป็นรายการที่เทียบเคียงคุณสามารถใช้

แต่((x == a and y == b) or (x == b and y == a))ชัดเจนปลอดภัยและทั่วๆไป

เป็นการวางนัยให้กับตัวแปรมากกว่าสองตัวที่เราสามารถitertools.permutationsใช้ได้ นั่นคือแทน

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

เราสามารถเขียน

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

และแน่นอนว่ารุ่นตัวแปรสองตัว:

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

คุณสามารถใช้สิ่งอันดับเพื่อแสดงข้อมูลของคุณจากนั้นตรวจสอบการรวมชุดเช่น:

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

    return (x, y) in test_set

คุณมีวิธีแก้ไขปัญหาที่อ่านได้มากที่สุดแล้วแล้ว มีวิธีอื่นในการแสดงสิ่งนี้อาจมีตัวอักษรน้อยลง แต่มีน้อยกว่าในการอ่าน

ทั้งนี้ขึ้นอยู่กับสิ่งที่มีค่าจริงแทนทางออกที่ดีที่สุดของคุณคือการตัดการตรวจสอบในการทำงานที่มีชื่อที่พูด หรือนอกจากนี้คุณสามารถจำลองวัตถุ x, y และ a, b ในวัตถุชั้นสูงโดยเฉพาะที่คุณสามารถเปรียบเทียบกับตรรกะของการเปรียบเทียบในวิธีการตรวจสอบความเท่าเทียมกันของคลาสหรือฟังก์ชันที่กำหนดเองโดยเฉพาะ

ดูเหมือนว่า OP จะเกี่ยวข้องกับกรณีของตัวแปรสองตัวเท่านั้น แต่เนื่องจาก StackOverflow สำหรับผู้ที่ค้นหาคำถามเดียวกันในภายหลังด้วยฉันจะพยายามจัดการกรณีทั่วไปที่นี่ในรายละเอียด หนึ่งคำตอบก่อนหน้านี้มีคำตอบทั่วไปที่ใช้อยู่itertools.permutations()แต่วิธีการนั้นนำไปสู่การO(N*N!)เปรียบเทียบเนื่องจากมีN!วิธีเรียงสับเปลี่ยนNแต่ละรายการ (นี่คือแรงจูงใจหลักสำหรับคำตอบนี้)

ก่อนอื่นเรามาสรุปว่าวิธีการบางอย่างในคำตอบก่อนหน้านี้นำไปใช้กับกรณีทั่วไปได้อย่างไรเป็นแรงจูงใจสำหรับวิธีที่นำเสนอที่นี่ ฉันจะใช้Aเพื่ออ้างถึง(x, y)และBอ้างถึง(a, b)ซึ่งอาจเป็นสิ่งอันดับความยาวตามอำเภอใจ (แต่เท่ากัน)

set(A) == set(B)รวดเร็ว แต่ใช้ได้เฉพาะในกรณีที่ค่าแฮชและคุณสามารถรับประกันได้ว่าหนึ่งใน tuples ไม่มีค่าที่ซ้ำกัน (เช่น.{1, 1, 2} == {1, 2, 2}ระบุโดย @ user2357112 ภายใต้คำตอบของ @Daniel Mesejo)

วิธีก่อนหน้านี้สามารถขยายเพื่อทำงานกับค่าที่ซ้ำกันโดยใช้พจนานุกรมที่มีการนับแทนชุด: (ซึ่งยังมีข้อ จำกัด ว่าค่าทั้งหมดจะต้อง hashable ดังนั้นเช่นค่าที่ไม่แน่นอนเช่นlistจะไม่ทำงาน)

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)ไม่ต้องใช้ค่าแฮช แต่จะช้ากว่าเล็กน้อยและต้องการค่าที่สามารถสั่งซื้อได้แทน (เช่นเช่นcomplexจะไม่ทำงาน)

A in itertools.permutations(B)ไม่ต้องการค่าแฮชหรือค่าสั่งซื้อ แต่อย่างที่กล่าวไปแล้วว่ามันมีO(N*N!)ความซับซ้อนดังนั้นแม้จะมีเพียง 11 รายการก็สามารถใช้เวลาหนึ่งวินาทีในการเสร็จสิ้น

ดังนั้นมีวิธีที่จะเป็นทั่วไป แต่เร็วขึ้นมาก? ทำไมใช่โดยการ "ตรวจสอบด้วยตนเอง" ว่ามีจำนวนเท่ากันในแต่ละรายการ: (ความซับซ้อนของอันนี้คือO(N^2)ดังนั้นสิ่งนี้จึงไม่ดีสำหรับอินพุตขนาดใหญ่เช่นกันบนเครื่องของฉันรายการ 10k อาจใช้เวลาไม่เกินวินาที - อินพุตที่เล็กลงเช่น 10 รายการนี่เร็วพอ ๆ กับรายการอื่น ๆ )

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

เพื่อให้ได้ประสิทธิภาพที่ดีที่สุดเราอาจต้องการลองdictใช้เมธอด -based ก่อนถอยกลับไปที่sortedเมธอด -based หากล้มเหลวเนื่องจากค่า unhashable และในที่สุดก็กลับไปcountใช้เมธอด -based หากล้มเหลวเนื่องจากค่าที่ไม่สามารถจัดลำดับได้