ट्यूपल परिभाषाओं में अल्पविरामों के अनुगामी होने का वाक्यविन्यास नियम क्या है?

119

एकल तत्व टपल के मामले में, अनुगामी अल्पविराम की आवश्यकता होती है।

a = ('foo',)

कई तत्वों के साथ एक टपल के बारे में क्या? ऐसा लगता है कि अनुगामी अल्पविराम मौजूद है या नहीं, वे दोनों वैध हैं। क्या ये सही है? मेरे विचार में संपादन के लिए अनुगामी अल्पविराम का होना आसान है। क्या यह एक खराब कोडिंग शैली है?

a = ('foo1', 'foo2')
b = ('foo1', 'foo2',)

python syntax tuples

— स्टेन
स्रोत

यहाँ वाक्यविन्यास नियम है: docs.python.org/reference/expressions.html#expression-lists

— Kirill

73

खाली ट्यूपल को छोड़कर सभी मामलों में कॉमा महत्वपूर्ण चीज है। अन्य सिंटैक्टिक कारणों के लिए आवश्यक होने पर पेरेंटेस की आवश्यकता होती है: फ़ंक्शन तर्कों, ऑपरेटर पूर्ववर्तीता के एक सेट से या रेखा को तोड़ने की अनुमति देने के लिए एक ट्यूपल को भेद करने के लिए।

ट्यूपल्स, सूचियों, या कार्य तर्कों के लिए अनुगामी अल्पविराम विशेष रूप से अच्छी शैली है, जब आपके पास एक लंबा आरंभीकरण होता है जो कई लाइनों में विभाजित होता है। यदि आप हमेशा एक अनुगामी अल्पविराम शामिल करते हैं, तो आप एक और तत्व जोड़ने की अपेक्षा अंत में दूसरी पंक्ति नहीं जोड़ेंगे और इसके बजाय केवल एक मान्य लिंक बनाएँ:

a = [
   "a",
   "b"
   "c"
]

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

— डंकन
स्रोत

3

ऊपर बताए गए कारणों के लिए, अल्पविराम को छोड़ना फायदेमंद हो सकता है। दूसरी ओर, इस आदत को अपनाने से सिरदर्द हो सकता है यदि आप अपने आवेदन में जावास्क्रिप्ट या JSON के साथ कहीं और काम कर रहे हैं, क्योंकि कुछ ब्राउज़रों को यह पसंद नहीं है।

— साइटो

7

हां लेकिन, आपको कभी भी JSON का निर्माण हाथ से नहीं करना चाहिए ताकि कोई फर्क न पड़े और जावास्क्रिप्ट के लिए हमेशा ब्राउज़र के पास पहुंचने से पहले उस तरह की त्रुटि को पकड़ने के लिए jslint या समकक्ष का उपयोग करें।

— डंकन

100

यह केवल एकल-आइटम टुपल्स के लिए आवश्यक है जो एक टपल को परिभाषित करने या कोष्ठकों से घिरे एक अभिव्यक्ति को अलग करने के लिए है।

(1)  # the number 1 (the parentheses are wrapping the expression `1`)
(1,) # a 1-tuple holding a number 1

एक से अधिक आइटम के लिए, यह अब आवश्यक नहीं है क्योंकि यह पूरी तरह से स्पष्ट है यह एक टपल है। हालाँकि, अनुगामी अल्पविराम को कई लाइनों का उपयोग करके उन्हें परिभाषित करना आसान बनाने की अनुमति है। आप सिंटैक्स को तोड़ने के बिना अंत या पुनर्व्यवस्थित आइटम को जोड़ सकते हैं क्योंकि आपने दुर्घटना पर अल्पविराम छोड़ दिया है।

जैसे,

someBigTuple = (
                   0,
                   1,
                   2,
                   3,
                   4,
                   5,
                   6,
                   7,
                   8,
                   9,
                   10,
                   #...
                   10000000000,
               )

ध्यान दें कि यह अन्य संग्रह (जैसे, सूचियों और शब्दकोशों) पर भी लागू होता है और न केवल टुपल्स पर।

— जेफ मर्काडो
स्रोत

5

+1 यह इंगित करने के लिए कि यह ट्यूपल्स की तुलना में अन्य सामानों के लिए भी मान्य है। यह key: value,प्रति पंक्ति एक होने के लिए उपयोगी है , और नया सामान जोड़ते समय अल्पविराम का ध्यान न रखें।

— जोएल

46

कॉमा को पीछे हटाने का एक और फायदा यह है कि इससे डिफरेंस लुक अच्छा हो जाता है। अगर आपने साथ शुरू किया

a = [
    1,
    2,
    3
]

और इसे बदल दिया

a = [
    1,
    2,
    3,
    4
]

जैसा होगा वैसा ही दिखेगा

 a = [
     1,
     2,
-    3
+    3,
+    4
 ]

जबकि अगर आपने एक अनुगामी अल्पविराम के साथ शुरुआत की थी, जैसे

a = [
    1,
    2,
    3,
]

तब अंतर बस होगा

 a = [
     1,
     2,
     3,
+    4,
 ]

— asmeurer
स्रोत

यह वास्तव में मूल प्रश्न के उत्तर की तुलना में एक टिप्पणी का अधिक है, लेकिन मैं वास्तव में अनुगामी अल्पविराम के पक्ष में जोड़ा गया तर्क पसंद करता हूं।

— मैड

13

यह वैकल्पिक है: पायथन विकी देखें ।

सारांश: एकल-तत्व टुपल्स को एक अनुगामी अल्पविराम की आवश्यकता होती है , लेकिन यह कई-तत्व टुपल्स के लिए वैकल्पिक है ।

— डेव एवरिट
स्रोत

8

इसके अलावा, उस स्थिति पर विचार करें जहाँ आप चाहते हैं:

>>> (('x','y'))*4                         # same as ('x','y')*4
('x', 'y', 'x', 'y', 'x', 'y', 'x', 'y')
#Expected = (('x', 'y'), ('x', 'y'), ('x', 'y'), ('x', 'y'))

तो इस मामले में बाहरी कोष्ठक समूह कोष्ठक से ज्यादा कुछ नहीं हैं। उन्हें तुच्छ बनाने के लिए आपको एक अनुगामी अल्पविराम जोड़ना होगा। अर्थात

>>> (('x','y'),)*4 
(('x', 'y'), ('x', 'y'), ('x', 'y'), ('x', 'y'))

— MaPy
स्रोत

6

केवल एक-तत्व ट्यूपल्स के लिए ट्रेलिंग कॉमा की आवश्यकता होती है। बड़े टुपल्स के लिए अनुगामी अल्पविराम होना स्टाइल का विषय है और इसकी आवश्यकता नहीं है। इसका सबसे बड़ा लाभ बहु-पंक्ति बड़े ट्यूपल्स वाली फाइलों में साफ-सुथरा होता है जिन्हें अक्सर संशोधित किया जाता है (जैसे कॉन्फ़िगरेशन ट्यूपल्स)।

— एडम ज़ल्कमैन
स्रोत

6

यह एक सरल जवाब है।

a = ("s") एक स्ट्रिंग है

तथा

a = ("s"), एक तत्व के साथ एक ट्यूपल है।

एक तत्व टपल टू, स्ट्रिंग और टपल के बीच अंतर के मामले में पायथन को एक अतिरिक्त अल्पविराम की आवश्यकता होती है।

उदाहरण के लिए अजगर कंसोल पर यह प्रयास करें:

a = ("s")

a = a + (1,2,3)

ट्रेसबैक (सबसे हालिया कॉल अंतिम):

फ़ाइल स्टडिन, लाइन 1, मॉड्यूल में

TypeError: 'str' और 'tuple' ऑब्जेक्ट्स को समाप्‍त नहीं कर सकता

— रजनी कांत
स्रोत

4

एक और कारण यह मौजूद है कि यह कोड पीढ़ी और __repr__कार्यों को लिखना आसान बनाता है। उदाहरण के लिए, यदि आपके पास कुछ ऐसी वस्तु है जो निर्मित है obj(arg1, arg2, ..., argn), तो आप बस के obj.__repr__रूप में लिख सकते हैं

def __repr__(self):
    l = ['obj(']
    for arg in obj.args: # Suppose obj.args == (arg1, arg2, ..., argn)
        l.append(repr(arg))
        l.append(', ')
    l.append(')')
    return ''.join(l)

यदि अनुगामी अल्पविराम की अनुमति नहीं थी, तो आपको अंतिम तर्क विशेष मामले में देना होगा। वास्तव में, आप एक सूची समझ का उपयोग करके एक पंक्ति में ऊपर लिख सकते हैं (मैंने इसे आसानी से पढ़ने के लिए अधिक लंबा लिखा है)। ऐसा करना इतना आसान नहीं होगा कि अगर आपको अंतिम अवधि के लिए विशेष मामला करना पड़े।

— asmeurer
स्रोत

2

अंतिम तर्क के लिए विशेष-मामले की आवश्यकता नहीं होगी, एक joinउस मामले में उपयोग कर सकता है def __repr__(self): 'obj(' + ', '.join([repr(arg) for arg in obj.args]) + ')':।

— सुजैन डुपरॉन

यह कोड पीढ़ी के साथ भी मदद करता है, यहां तक कि उन उपकरणों से भी जो पायथन में नहीं लिखे गए हैं और जैसे अच्छे कार्य नहीं हैं join।

— asmeurer

2

पीईपी 8 - पायथन कोड के लिए स्टाइल गाइड - जब ट्रेलिंग कॉम का उपयोग करना है

ट्रेलिंग कॉमा आमतौर पर वैकल्पिक होते हैं, सिवाय इसके कि जब वे एक तत्व का एक टपल बनाते समय अनिवार्य होते हैं (और पायथन 2 में उनके पास प्रिंट स्टेटमेंट के लिए शब्दार्थ है)। स्पष्टता के लिए, बाद वाले (तकनीकी रूप से निरर्थक) कोष्ठकों को घेरने की सिफारिश की जाती है।

हाँ:

FILES = ('setup.cfg',)

ठीक है, लेकिन भ्रमित:

FILES = 'setup.cfg',

जब अनुगामी अल्पविराम निरर्थक होते हैं, तो वे अक्सर सहायक होते हैं जब एक संस्करण नियंत्रण प्रणाली का उपयोग किया जाता है, जब मूल्यों, तर्कों या आयातित वस्तुओं की सूची समय के साथ बढ़ने की उम्मीद होती है। पैटर्न को प्रत्येक मान को एक लाइन पर रखना है, हमेशा एक अनुगामी अल्पविराम जोड़ना है, और अगली पंक्ति में करीब कोष्ठक / ब्रैकेट / ब्रेस जोड़ना है। हालाँकि इसका मतलब यह नहीं है कि समापन रेखा के रूप में एक ही रेखा पर एक अल्पविराम अल्पविराम होता है (सिंगलटन ट्यूपल्स के उपरोक्त मामले को छोड़कर)।

हाँ:

FILES = [
    'setup.cfg',
    'tox.ini',
    ]
initialize(FILES,
           error=True,
           )

नहीं:

FILES = ['setup.cfg', 'tox.ini',]
initialize(FILES, error=True,)

— शीघ्र मिलान
स्रोत

-5

कोडिंग शैली आपका स्वाद है, अगर आपको लगता है कि मानक मामलों को कोड करना पीईपी -8 है जो आपको मार्गदर्शन कर सकता है।

निम्नलिखित अभिव्यक्ति के परिणाम के बारे में आप क्या सोचते हैं?

x = (3)
x = (3+2)
x = 2*(3+2)

हां, x सिर्फ एक संख्या है।

— Melug
स्रोत

1

यह आपकी विचारधारा की व्याख्या करने का एक खराब तरीका है। निहितार्थ की तुलना में स्पष्ट है।

— गिलहर्मे डेविड दा कोस्टा