एक तानाशाही को कम करने के लिए पसंदीदा वाक्यविन्यास क्या है: घुंघराले ब्रेसल {} या तानाशाही () फ़ंक्शन?

Question

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

मैं एक तानाशाही को शुरू करने के लिए दो सामान्य तरीके देखता हूं:

a = {
    'a': 'value',
    'another': 'value',
}

b = dict( 
    a='value',
    another='value',
)

जिसे "अधिक पायथोनिक" माना जाता है? जो आप उपयोग करते हैं? क्यों?

Comments

आप किस ट्यूटोरियल का उपयोग कर रहे हैं? आपने ऐसे उदाहरण कहां देखे जो भ्रम पैदा करते हैं?

— S.Lott

ठीक है, मैं पायथन ट्यूटोरियल, डाइव इन पाइथन और फिर विभिन्न प्रकार के ब्लॉग, एसओ पोस्ट और अन्य Googled संसाधनों का उपयोग कर रहा हूं। आधिकारिक डॉक्स {}बहुत समान रूप से उपयोग करते हैं , लेकिन मुझे बहुत स्पष्ट dict()दृष्टिकोण कहीं और दिखाई देता है। मैं एक स्पष्ट वाक्यविन्यास का लाभ देख सकता था, लेकिन आधिकारिक डॉक्स में दृष्टिकोण की अनुपस्थिति ने मुझे संदिग्ध बना दिया। इसे पोस्ट करने के बाद मैंने लाइब्रेरी डॉक्स को देखा dictऔर पाया कि जब किसी स्पष्ट dictको एक इनिशियलाइज़ करने के लिए उपयोग किया जाता है, तो कुंजी को वैध पहचानकर्ता होना चाहिए ।

— दतोआद

"{}" से अधिक "स्पष्ट ()" कैसे स्पष्ट है? मैं आपका भ्रम नहीं समझ रहा हूँ। दोनों मुझे स्पष्ट प्रतीत होते हैं। क्या आप कोई उद्धरण या संदर्भ प्रदान कर सकते हैं जो आपको "स्पष्ट" कहे "स्पष्ट" और "{}" स्पष्ट नहीं है? आपको क्या लगता है कि यह भेद कहाँ से उत्पन्न हुआ?

— एस.लॉट

भेद वर्तनी है। dict()वर्तनी है dict- यह प्रकार के नाम का उपयोग करता है। ब्रेसिज़ ( {}) प्रकार की पहचान करने के लिए विराम चिह्न पर निर्भर करते हैं।

— दतोआद

Answer 1

घुंघराले ब्रेसिज़। कीवर्ड तर्क पास करना dict(), हालांकि यह बहुत सारे परिदृश्यों में खूबसूरती से काम करता है, केवल एक मैप को इनिशियलाइज़ कर सकता है यदि कुंजी वैध पायथन आइडेंटिफ़ायर हैं।

यह काम:

a = {'import': 'trade', 1: 7.8}

a = dict({'import': 'trade', 1: 7.8})

यह काम नहीं करेगा:

a =                  dict(import='trade', 1=7.8)
>> SyntaxError: invalid syntax  ^

Answer 2

सबसे पहले, घुंघराले ब्रेसिज़। अन्यथा, आप उन कुंजियों के साथ संगतता मुद्दों में भाग लेते हैं जिनमें अजीब चरित्र होते हैं, जैसे =।

# Works fine.
a = {
    'a': 'value',
    'b=c': 'value',
}

# Eeep! Breaks if trying to be consistent.
b = dict( 
    a='value',
    b=c='value',
)

Comments

यह वास्तव में इसलिए है कि कोई भी आरंभिक के लिए तानाशाही () पद्धति को पसंद कर सकता है, यह शब्दकोश की कुंजियों को मान्य पहचानकर्ता होने के लिए मजबूर करता है, इसलिए वे उदाहरण के लिए, ** kwargs के साथ संगत हैं, और चाबियाँ मान्य विशेषता नाम हैं।

— RufusVS

Answer 3

पहला संस्करण बेहतर है:

• यह सभी प्रकार की कुंजियों के लिए काम करता है, इसलिए आप, उदाहरण के लिए, कह सकते हैं {1: 'one', 2: 'two'}। दूसरा संस्करण केवल (कुछ) स्ट्रिंग कुंजी के लिए काम करता है। कुंजियों के प्रकार के आधार पर विभिन्न प्रकार के सिंटैक्स का उपयोग करना एक अनावश्यक असंगति होगी।

• यह तेज है:

  $ python -m timeit "dict(a='value', another='value')"
  1000000 loops, best of 3: 0.79 usec per loop
  $ python -m timeit "{'a': 'value','another': 'value'}"
  1000000 loops, best of 3: 0.305 usec per loop

• यदि शब्दकोश शाब्दिक के लिए विशेष वाक्यविन्यास का उपयोग करने का इरादा नहीं था, तो यह संभवतः मौजूद नहीं होगा।

Answer 4

मुझे लगता है कि पहला विकल्प बेहतर है क्योंकि आप मानों को ['ए'] या ['अन्य'] के रूप में एक्सेस करने जा रहे हैं। आपके शब्दकोश की कुंजियाँ स्ट्रिंग हैं, और ऐसा कोई कारण नहीं है कि वे दिखावा न करें। मेरे लिए कीवर्ड सिंटैक्स पहले तो चालाक दिखता है, लेकिन दूसरी नज़र में अस्पष्ट। यह केवल मेरे लिए समझ में आता है यदि आप साथ काम कर रहे हैं __dict__, और कीवर्ड बाद में विशेषता बनने जा रहे हैं, ऐसा ही कुछ।

Answer 5

FYI करें, यदि आपको अपने डिक्शनरी में विशेषताएँ जोड़ने की ज़रूरत है (ऐसी चीज़ें जो डिक्शनरी से जुड़ी हुई हैं, लेकिन उनमें से एक भी नहीं हैं), तो आपको दूसरे फॉर्म की आवश्यकता होगी। उस स्थिति में, आप अपने शब्दकोश को शुरुआती अक्षरों के साथ मनमानी कर सकते हैं, एक बार में, जैसे:

    class mydict(dict): pass
    a = mydict()        
    a["b=c"] = 'value'
    a.test = False

Answer 6

कभी-कभी dict()एक अच्छा विकल्प होता है:

a=dict(zip(['Mon','Tue','Wed','Thu','Fri'], [x for x in range(1, 6)]))

mydict=dict(zip(['mon','tue','wed','thu','fri','sat','sun'],

[random.randint (0,100) x के लिए रेंज में (0,7)]))

Comments

एक शानदार समारोह है जो इसे बेहतर कर सकता है। उस मामले के लिए, एक Enum प्रकार है जो आप यहाँ बेहतर कर रहे हैं वह कर सकता है। इसके अलावा, यह वास्तव में सवाल का जवाब नहीं है।

— दशक्रेडर

Answer 7

मैं लगभग हमेशा घुंघराले-ब्रेसिज़ का उपयोग करता हूं; हालाँकि, कुछ मामलों में जहां मैं परीक्षण लिख रहा हूं, मैं कीवर्ड पैकिंग / अनपैकिंग करता हूं, और इन मामलों में तानाशाही () बहुत अधिक रखरखाव योग्य है, क्योंकि मुझे बदलने की आवश्यकता नहीं है:

a=1,
b=2,

सेवा:

'a': 1,
'b': 2,

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

कार्यान्वयन में ही, अनुकूलन के साथ मेरे जुनून के कारण, और जब मुझे विशेष रूप से बहुत बड़ी स्थिरता का लाभ नहीं दिखता है, तो मैं हमेशा घुंघराले ब्रेसिज़ का पक्ष लूंगा।

परीक्षणों और कार्यान्वयन में, मैं कभी भी तानाशाही का उपयोग नहीं करता () अगर वहाँ एक मौका है कि चाबियाँ तब या भविष्य में जोड़ा जाता है।

• हमेशा एक तार नहीं होना चाहिए
• न केवल अंक, ASCII पत्र और अंडरस्कोर होते हैं
• पूर्णांक के साथ प्रारंभ करें ( dict(1foo=2)एक SyntaxError उठाता है)