python - व्यक्त करने के लिए एक और अधिक सुंदर तरीका है((x== a और y== b) या(x== b और y== a))?




boolean-logic (7)

मैं पायथन में ((x == a and y == b) or (x == b and y == a)) का मूल्यांकन करने की कोशिश कर रहा हूं, लेकिन यह थोड़ा वर्बोज़ लगता है। वहाँ एक और अधिक सुंदर तरीका है?


Tuples इसे थोड़ा और पठनीय बनाते हैं:

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

यह एक सुराग देता है: हम जाँच रहे हैं कि क्या सूची x, y सूची a, b समान a, b लेकिन आदेश की अनदेखी कर रही है। यह सिर्फ समानता है!

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

आप अपने डेटा का प्रतिनिधित्व करने के लिए ट्यूपल्स का उपयोग कर सकते हैं और फिर सेट अपवर्जन के लिए जांच कर सकते हैं, जैसे:

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

    return (x, y) in test_set

दो से अधिक चरों के सामान्यीकरण के रूप में हम 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])

मुझे लगता है कि आपको जो सबसे अच्छा मिल सकता है, वह उन्हें टुपल्स में पैकेज करना है:

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

या, हो सकता है कि एक सेट लुकअप में लपेटें

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

बस जब से यह एक दो टिप्पणियों द्वारा उल्लेख किया गया था, मैंने कुछ समय किया, और लुकअप और सेट यहां दिखाई देने वाले प्रदर्शनों को प्रदर्शित करते हैं:

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

हालांकि लुकअप के सफल होने पर टुपल्स वास्तव में तेज़ होते हैं:

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

मैंने एक सेट का उपयोग करने के लिए चुना क्योंकि मैं एक सदस्यता लुकअप कर रहा हूं, और वैचारिक रूप से एक सेट एक ट्यूपल की तुलना में उस उपयोग-मामले के लिए एक बेहतर फिट है। यदि आपने किसी विशेष उपयोग के मामले में दो संरचनाओं के बीच एक महत्वपूर्ण अंतर मापा है, तो तेज के साथ जाएं। मुझे नहीं लगता कि प्रदर्शन यहाँ एक कारक है।


यदि आइटम उपलब्ध नहीं हैं, लेकिन तुलना का आदेश देने का समर्थन करते हैं, तो आप कोशिश कर सकते हैं:

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

यदि तत्व उपलब्ध हैं, तो आप सेट का उपयोग कर सकते हैं:

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

आपको पहले से ही सबसे पठनीय हल मिल गया । इसे व्यक्त करने के अन्य तरीके हैं, शायद कम पात्रों के साथ, लेकिन वे पढ़ने के लिए कम-सीधे हैं।

वास्तव में आपके सर्वोत्तम दांव का प्रतिनिधित्व करने वाले मूल्यों के आधार पर, एक फ़ंक्शन में चेक को बोलने वाले नाम के साथ लपेटना है । वैकल्पिक रूप से या इसके अलावा, आप वस्तुओं को x, y और a, b को समर्पित उच्च श्रेणी की वस्तुओं में से प्रत्येक में मॉडल कर सकते हैं जिन्हें आप तब वर्ग समानता जांच विधि या एक समर्पित कस्टम फ़ंक्शन में तुलना के तर्क के साथ तुलना कर सकते हैं।





boolean-logic