[python] एक ही समय में एकाधिक चर घोषित करने का अधिक सुरुचिपूर्ण तरीका



3 Answers

a, b, c, d, e, g, h, i, j = (True,)*9
f = False
Question

"एक ही समय" में कई चर घोषित करने के लिए मैं करूँगा:

a, b = True, False

लेकिन अगर मुझे और अधिक चर घोषित करना पड़ा, तो यह कम और कम सुरुचिपूर्ण हो जाता है:

a, b, c, d, e, f, g, h, i, j = True, True, True, True, True, False, True ,True , True, True

क्या ऐसा करने के लिए एक बेहतर / सुरुचिपूर्ण / सुविधाजनक तरीका है?

अग्रिम में धन्यवाद!

संपादित करें:

यह बहुत बुनियादी होना चाहिए, लेकिन यदि मैं चरों को संग्रहित करने के लिए एक सूची या टुपल का उपयोग करता हूं, तो मुझे कैसे संपर्क करना होगा ताकि मैं सहायक हो जाऊं:

aList = [a,b]

मान्य नहीं है, मुझे करना होगा:

a, b = True, True

या मुझे क्या याद आ रही है?




मुझे शीर्ष वोट दिया गया जवाब पसंद है; हालांकि, दिखाए गए अनुसार सूची में समस्याएं हैं।

  >> a, b = ([0]*5,)*2
  >> print b
  [0, 0, 0, 0, 0]
  >> a[0] = 1
  >> print b
  [1, 0, 0, 0, 0]

इस पर महान विवरण (here) में चर्चा की गई है, लेकिन यह बात यह है कि a और b a ही वस्तु है जिसके साथ a is b True ( id(a) == id(b) )। इसलिए यदि आप एक इंडेक्स बदलते हैं, तो आप a और b दोनों के इंडेक्स को बदल रहे हैं, क्योंकि वे जुड़े हुए हैं। इसे हल करने के लिए आप source कर सकते हैं

>> a, b = ([0]*5 for i in range(2))
>> print b
[0, 0, 0, 0, 0]
>> a[0] = 1
>> print b
[0, 0, 0, 0, 0]

इसके बाद इसे शीर्ष उत्तर के एक संस्करण के रूप में उपयोग किया जा सकता है, जिसमें "वांछित" अंतर्ज्ञानी परिणाम होते हैं

>> a, b, c, d, e, g, h, i = (True for i in range(9))
>> f = (False for i in range(1)) #to be pedantic



यह @ जेफ एम और मेरी टिप्पणियों पर एक विस्तार है।

जब आप ऐसा करते हैं:

a, b = c, d

यह ट्यूपल पैकिंग और अनपॅकिंग के साथ काम करता है। आप पैकिंग और अनपॅकिंग चरणों को अलग कर सकते हैं:

_ = c, d
a, b = _

पहली पंक्ति _ नामक एक टुपल बनाती है जिसमें दो तत्व होते हैं, पहले c के मान के साथ पहला और दूसरा d के मान के साथ होता है। दूसरी पंक्ति _ और b को चर के रूप में _ tuple unpacks unpacks। यह आपकी एक बड़ी रेखा को तोड़ देता है:

a, b, c, d, e, f, g, h, i, j = True, True, True, True, True, False, True, True, True, True

दो छोटी लाइनों में:

_ = True, True, True, True, True, False, True, True, True, True
a, b, c, d, e, f, g, h, i, j = _

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

यदि आपके पास मूल्यों की एक सूची है, तो आप अभी भी उन्हें अनपैक कर सकते हैं। आपको बस इसे पहले एक टुपल में बदलना होगा। उदाहरण के लिए, निम्नलिखित क्रमशः j माध्यम से प्रत्येक के लिए 0 और 9 के बीच मान असाइन करेगा:

a, b, c, d, e, f, g, h, i, j = tuple(range(10))

संपादित करें: तत्व 5 को छोड़कर सभी को सत्य के रूप में असाइन करने के लिए स्वच्छ चाल (परिवर्तनीय f ):

a, b, c, d, e, f, g, h, i, j = tuple(x != 5 for x in range(10))



वास्तव में समस्या क्या है?

यदि आपको वास्तव में 10 , बी , सी , डी , , एफ , जी , एच , आई , जे की आवश्यकता है या चाहते हैं, तो एक और दूसरी बार, लिखने और लिखने के लिए कोई अन्य संभावना नहीं होगी और सी लिखें। ....

यदि मूल्य सभी अलग हैं, तो आप उदाहरण के लिए लिखने के लिए बाध्य होंगे

a = 12
b= 'sun'
c = A() #(where A is a class)
d = range(1,102,5)
e = (line in filehandler if line.rstrip())
f = 0,12358
g = True
h = random.choice
i = re.compile('^(!=  ab).+?<span>')
j = [78,89,90,0]

यह अलग-अलग "चर" को परिभाषित करना है।

या, एक और लेखन का उपयोग, उपयोग करने की कोई ज़रूरत नहीं _ :

a,b,c,d,e,f,g,h,i,j =\
12,'sun',A(),range(1,102,5),\
(line for line in filehandler if line.rstrip()),\
0.12358,True,random.choice,\
re.compile('^(!=  ab).+?<span>'),[78,89,90,0]

या

a,b,c,d,e,f,g,h,i,j =\
(12,'sun',A(),range(1,102,5),
 (line for line in filehandler if line.rstrip()),
 0.12358,True,random.choice,
 re.compile('^(!=  ab).+?<span>'),[78,89,90,0])

अगर उनमें से कुछ के पास एक ही मूल्य होना चाहिए, तो समस्या यह है कि लिखना बहुत लंबा है

a, b, c, d, e, f, g, h, i, j = True, True, True, True, True, False, True ,True , True, True 

?

फिर आप लिख सकते हैं:

a=b=c=d=e=g=h=i=k=j=True
f = False

मुझे समझ में नहीं आता कि आपकी समस्या वास्तव में क्या है। यदि आप एक कोड लिखना चाहते हैं, तो आप निर्देशों और परिभाषाओं के लेखन द्वारा आवश्यक पात्रों का उपयोग करने के लिए बाध्य हैं। और क्या ?

मुझे आश्चर्य है कि आपका प्रश्न यह संकेत नहीं है कि आप कुछ गलत समझते हैं।

जब कोई a = 10 लिखता a = 10 , तो कोई "स्मृति के खंड" के अर्थ में एक चर नहीं बनाता जिसका मूल्य बदल सकता है "। यह निर्देश:

  • या तो इस नाम के साथ वर्तमान नामस्थान में प्रकार integer और मान 10 की एक वस्तु के निर्माण और 'ए' के ​​बाध्यकारी को ट्रिगर करता है

  • या ऑब्जेक्ट 10 में नामस्थान में नाम 'ए' को फिर से असाइन करें (क्योंकि 'ए' को किसी अन्य ऑब्जेक्ट से पहले बाध्य किया गया था)

मैं कहता हूं कि क्योंकि मुझे 10 पहचानकर्ताओं को परिभाषित करने के लिए उपयोगिता नहीं दिखाई देती है, बी, सी ... गलत या सही पर इशारा करते हुए। यदि निष्पादन के दौरान ये मान नहीं बदलते हैं, तो 10 पहचानकर्ता क्यों? और यदि वे बदलते हैं, तो पहचानकर्ताओं को पहले क्यों परिभाषित किया जाता है? अगर उन्हें पहले परिभाषित नहीं किया गया तो वे बनाए जाएंगे

आपका प्रश्न मेरे लिए अजीब लगता है




Related