पायथॉन 3.4+ में, मुझे साधारण नाम से अधिक नामांक का उपयोग क्यों करना चाहिए जब तानाशाही का उपयोग नहीं किया जाता है, तो वे बहुत समान लगते हैं

11

एक बिंदु या किसी अन्य पर आप बहुत सारे तर्कों के साथ कार्य कर सकते हैं। कभी-कभी यह कुछ तर्कों को सुपर-तर्कों में संयोजित करने के लिए समझ में आता है। मैंने अक्सर ऐसा डाइट्स के साथ किया है, लेकिन अब मैं इसे करने के बेहतर तरीके देख रहा हूं।

मैं मोड़ना चाहूंगा ...

def do_something(ax, ay, az, bu, bv, c):
    # Do something

... में ...

def do_something(a, b, c):
    # Do something

... जहां aऔर जहां bउनके उपनियम होते हैं।

ऐसा करने का एक तरीका यह है:

A = namedtuple('A', 'x, y, z')
a = A(ax, ay, az)
B = namedtuple('B', 'u, v')
b = B(bu, bv)

हालाँकि, यह सरल लगता है:

a = SimpleNamespace(x=ax, y=ay, z=az)
b = SimpleNamespace(u=bu, v=bv)

क्या है कमी? तथ्य यह है कि aऔर bअच्छी तरह से टाइप नहीं कर रहे हैं? वे ए और बी ऑब्जेक्ट नहीं हैं?

(Btw, चर नामों के बारे में चिंता न करें। मैं आमतौर पर छोटे चर नामों के रूप में उपयोग नहीं करता हूं।)

python variables dictionary

— आंद्रे क्रिस्टोफर एंडरसन
स्रोत

1

प्रति se में कोई कमियां नहीं हैं, वे सिर्फ अलग चीजें हैं। स्टार्टर के लिए नामपट्ट्स अयोग्य हैं जबकि नाम स्थान परस्पर भिन्न हैं। क्या उत्परिवर्तनीय बेहतर या अयोग्य से भी बदतर है? यह इस बात पर निर्भर करता है कि आपको क्या चाहिए या क्या चाहिए, कई मामलों में यह मायने नहीं रखता। आप फ़ंक्शन संभवतः आवश्यक विशेषताओं के साथ किसी भी ऑब्जेक्ट के साथ काम करेंगे, इसे कैसे कॉल करने वाले को बनाना है।

— मोनिका

@ गोयो धन्यवाद। "कमी" यह कहने का एक भद्दा तरीका था। मेरा मतलब यह नहीं था कि एक का मतलब दूसरे से बेहतर है। बस पेशेवरों और विपक्ष चाहता था। एक बार फिर धन्यवाद।

— आंद्रे क्रिस्टोफर एंडरसन

1

क्या चौथी पंक्ति को "b = B (bu, bv)" की तरह नहीं देखना चाहिए?

— एलन सिल्जाक

@AlenSiljak हाँ यह चाहिए। मैं अब इसे ठीक कर दूंगा।

— एंड्रे क्रिस्टोफर एंडरसन

21

SimpleNamespaceमूल रूप से एक शब्दकोश के शीर्ष पर सिर्फ एक अच्छा मुखौटा है। यह आपको सूचकांक कुंजियों के बजाय गुणों का उपयोग करने की अनुमति देता है। यह अच्छा है क्योंकि यह सुपर लचीला है और हेरफेर करना आसान है।

उस लचीलेपन का नकारात्मक पक्ष यह है कि यह कोई संरचना प्रदान नहीं करता है। किसी को कॉल करने से रोकना नहीं है SimpleNamespace(x=ax, y=ay)(और del a.zबाद में किसी बिंदु पर)। यदि यह उदाहरण आपके फ़ंक्शन में पास हो जाता है, तो अपवाद तब होता है जब आप फ़ील्ड तक पहुँचने का प्रयास करते हैं।

इसके विपरीत, namedtupleआप एक संरचित प्रकार बनाते हैं। प्रकार का एक नाम होगा और यह पता चलेगा कि इसे किन क्षेत्रों में होना चाहिए। आप उनमें से प्रत्येक क्षेत्र के बिना एक उदाहरण बनाने में सक्षम नहीं होंगे और उन्हें बाद में हटाया नहीं जा सकता। इसके अतिरिक्त, उदाहरण अपरिवर्तनीय है, इसलिए आपको पता चल जाएगा कि मूल्य a.xहमेशा समान रहेगा।

यह तय करना आपके लिए है कि SimpleNamespaceआपको लचीलेपन की आवश्यकता है जो आपको देता है, या यदि आप संरचना और गारंटी प्रदान करना पसंद करते हैं namedtuple।

— unholysampler
स्रोत

2

मुझे वास्तव में संरचित बनाम नहीं के बारे में जवाब पसंद है, इसलिए मैं नीचे एक ठोस उदाहरण प्रदान कर रहा हूं।

SimpleNamespaceके साथ शुरू होने वाली कुंजियों को स्वीकार करेंगे _। यदि आप मोड़ने के लिए एक त्वरित और आसान तरीका ढूंढ रहे हैं, तो कहें, JSON आप फ़ील्ड नामों के साथ वस्तुओं में नियंत्रित नहीं करते हैं, यह बहुत आसान है:

d = {"_id": 2342122, "text": "hi there!"} # Elasticsearch gives this id!
e = SimpleNamespace(**d) # works
Name = namedtuple("Name", sorted(d)) # ValueError so we can't do Name(**d)

ऊपर ध्यान दें कि आप देख सकते हैं कि namedtupleहमें एक पूरी अतिरिक्त वस्तु मिलती है जो SimpleNamespaceकभी नहीं होगी। प्रत्येक SimpleNamespaceवास्तव में एक "अद्वितीय हिमपात का एक खंड" है, जबकि namedtupleकिसी भी ठोस मूल्यों के साथ तात्कालिक होने के बिना मौजूद है। जहां कहीं भी आपको ऐसे ठोस तत्वों की आवश्यकता होती है जो ठोस मूल्यों पर सामान्य होते हैं, तो आपको शायद इसे पसंद करना चाहिए।

— एलेक्स मूर-नीमी
स्रोत

1

का सारांश SimpleNamespace

यह ऑब्जेक्ट का निर्माण करते समय विशेषताओं को शुरू करने की अनुमति देता है:

sn = SimpleNamespace(a=1, b=2)

यह एक पठनीय प्रदान करता है

repr(): eval(repr(sn)) == sn

यह डिफ़ॉल्ट तुलना को ओवरराइड करता है। इसके बजाय तुलना करने के बजाय id(), यह गुण मानों की तुलना करता है।

— व्लाद बेजेन
स्रोत