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




variables declaration (8)

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

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

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


Answers

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

यदि आपको वास्तव में 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 पहचानकर्ता क्यों? और यदि वे बदलते हैं, तो पहचानकर्ताओं को पहले क्यों परिभाषित किया जाता है? अगर उन्हें पहले परिभाषित नहीं किया गया तो वे बनाए जाएंगे

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


लगता है जैसे आप अपनी समस्या का सामना कर रहे हैं मेरे लिए गलत तरीका।

अपने डेटा को टुपल का उपयोग करने के लिए लिखें या सभी डेटा स्टोर करने के लिए कक्षा लिखें।


अपनी सूची को परिभाषित करने के लिए एक सूची / शब्दकोश का प्रयोग करें या अपनी खुद की कक्षा को परिभाषित करें, लेकिन यदि आपको उन सभी चरों की आवश्यकता है जो आप कर सकते हैं:

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

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

इसके बजाय, आप उन्हें एक बड़ी डेटा संरचना में इकट्ठा करना चाहते हैं जिसे एक स्थानीय चर में संग्रहीत किया जा सकता है।

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

तो आप कुछ ऐसा कर सकते हैं:

# Define the attributes of our named tuple
from collections import namedtuple
DataHolder = namedtuple("DataHolder", "a b c d e f g")

# Store our data
data = DataHolder(True, True, True, True, True, False, True)

# Retrieve our data
print(data)
print(data.a, data.f)

वास्तविक कोड उम्मीद है कि "डेटाहोल्डर" और वर्णमाला के अक्षरों की तुलना में अधिक सार्थक नामों का उपयोग करें।


जैसा कि अन्य ने सुझाव दिया है, यह संभावना नहीं है कि बूलियन मूल्यों के साथ 10 अलग-अलग स्थानीय चर का उपयोग करना आपके दिनचर्या को लिखने का सबसे अच्छा तरीका है (विशेष रूप से यदि उनके पास वास्तव में एक-अक्षर नाम हैं :)

आप जो कर रहे हैं उसके आधार पर, इसके बजाय एक शब्दकोश का उपयोग करना समझ में आता है। उदाहरण के लिए, यदि आप एक-अक्षर झंडे के सेट के लिए बूलियन प्रीसेट मान सेट अप करना चाहते हैं, तो आप यह कर सकते हैं:

>>> flags = dict.fromkeys(["a", "b", "c"], True)
>>> flags.update(dict.fromkeys(["d", "e"], False))
>>> print flags
{'a': True, 'c': True, 'b': True, 'e': False, 'd': False}

यदि आप चाहें, तो आप इसे एक असाइनमेंट स्टेटमेंट के साथ भी कर सकते हैं:

>>> flags = dict(dict.fromkeys(["a", "b", "c"], True),
...              **dict.fromkeys(["d", "e"], False))
>>> print flags
{'a': True, 'c': True, 'b': True, 'e': False, 'd': False}

dict लिए दूसरा पैरामीटर पूरी तरह से इस के लिए डिज़ाइन नहीं किया गया है: यह वास्तव में आपको d=False जैसे कीवर्ड तर्कों का उपयोग करके शब्दकोश के अलग-अलग तत्वों को ओवरराइड करने की अनुमति देने के लिए है। उपर्युक्त कोड अभिव्यक्ति के परिणाम को ** बाद तर्कसंगत फ़ंक्शन में दिए गए कीवर्ड तर्कों के एक सेट में उड़ाता है। यह निश्चित रूप से शब्दकोश बनाने का एक विश्वसनीय तरीका है, और लोग कम से कम इस मुहावरे को स्वीकार करते हैं, लेकिन मुझे संदेह है कि कुछ इसे अनपेथोनिक मान सकते हैं। </disclaimer>

फिर भी एक और दृष्टिकोण, जो संभवतः सबसे अधिक सहज ज्ञान युक्त है, यदि आप अक्सर इस पैटर्न का उपयोग करेंगे, तो फ्लैग मानों (एकल-वर्ण तार) के लिए मैप किए गए ध्वज मूल्यों ( True , False ) की सूची के रूप में अपने डेटा को परिभाषित करना है। फिर आप इस डेटा परिभाषा को एक उलटा शब्दकोश में बदल देते हैं जो फ़्लैग नामों को ध्वजांकित करने के लिए नक्शा बनाता है। यह एक घोंसला सूची समझ के साथ काफी संक्षेप में किया जा सकता है, लेकिन यहां एक बहुत ही पठनीय कार्यान्वयन है:

>>> def invert_dict(inverted_dict):
...     elements = inverted_dict.iteritems()
...     for flag_value, flag_names in elements:
...         for flag_name in flag_names:
...             yield flag_name, flag_value
... 
>>> flags = {True: ["a", "b", "c"], False: ["d", "e"]}
>>> flags = dict(invert_dict(flags))
>>> print flags
{'a': True, 'c': True, 'b': True, 'e': False, 'd': False}

समारोह invert_dict एक जेनरेटर फ़ंक्शन है । यह उत्पन्न करता है , या पैदा करता है - जिसका अर्थ यह है कि यह बार-बार मूल्य-मूल्य जोड़ों के मान देता है । उन महत्वपूर्ण मूल्य जोड़े प्रारंभिक flags शब्दकोश के दो तत्वों की सामग्री के विपरीत हैं। उन्हें dict कन्स्ट्रक्टर में खिलाया जाता है। इस मामले में dict कन्स्ट्रक्टर ऊपर से अलग काम करता है क्योंकि इसे एक तर्क के बजाय एक शब्दकोष के रूप में खिलाया जा रहा है।

@ क्रिस लुट्ज़ की टिप्पणी पर चित्रण: यदि आप वास्तव में एकल-वर्ण मानों के लिए इसका उपयोग करेंगे, तो आप वास्तव में कर सकते हैं

>>> flags = {True: 'abc', False: 'de'}
>>> flags = dict(invert_dict(flags))
>>> print flags
{'a': True, 'c': True, 'b': True, 'e': False, 'd': False}

यह काम करता है क्योंकि पायथन स्ट्रिंग्स iterable , जिसका अर्थ है कि उन्हें मूल्य के आधार पर मूल्य के माध्यम से स्थानांतरित किया जा सकता है। स्ट्रिंग के मामले में, मान स्ट्रिंग में अलग-अलग वर्ण होते हैं। इसलिए जब उन्हें पुनरावृत्तियों के रूप में व्याख्या किया जा रहा है, इस मामले में जहां उनका उपयोग लूप में किया जा रहा है, ['a', 'b', 'c'] और 'abc' प्रभावी रूप से बराबर हैं। एक और उदाहरण तब होगा जब उन्हें एक ऐसे समारोह में पारित किया जा रहा है जो ट्यूबल की तरह एक पुनरावृत्त हो।

मैं व्यक्तिगत रूप से ऐसा नहीं करता क्योंकि यह सहजता से नहीं पढ़ता है: जब मैं एक स्ट्रिंग देखता हूं, तो मुझे उम्मीद है कि इसे सूची के बजाय एक मूल्य के रूप में उपयोग किया जाए। तो मैं पहली पंक्ति को देखता हूं और सोचता हूं "ठीक है, तो एक असली झंडा और झूठा झंडा है।" तो हालांकि यह एक संभावना है, मुझे नहीं लगता कि यह जाने का रास्ता है। उलझन में, यह पुनरावृत्तियों और पुनरावृत्तियों की अवधारणाओं को और स्पष्ट रूप से समझाने में मदद कर सकता है।

फ़ंक्शन invert_dict को परिभाषित करना जैसे कि यह वास्तव में एक शब्दकोश देता है, कोई बुरा विचार नहीं है; मैंने ज्यादातर ऐसा नहीं किया क्योंकि यह वास्तव में यह समझाने में मदद नहीं करता कि नियमित काम कैसे करता है।

स्पष्ट रूप से पायथन 2.7 में शब्दकोश समझ है, जो उस कार्य को लागू करने के लिए एक बेहद संक्षिप्त तरीका बनाती है। यह पाठक के लिए एक अभ्यास के रूप में छोड़ दिया गया है, क्योंकि मेरे पास पाइथन 2.7 स्थापित नहीं है :)

आप कुछ फ़ंक्शंस को कभी-बहुमुखी itertools मॉड्यूल से भी जोड़ सकते हैं। जैसा कि वे कहते हैं, ऐसा करने के लिए एक तरीका है । रुको, पाइथन लोग यह नहीं कहते हैं। खैर, यह कुछ मामलों में वैसे भी सच है। मुझे लगता है कि गुइडो ने हमें शब्दकोश समझने के लिए दिया है ताकि ऐसा करने का एक स्पष्ट तरीका होगा।


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

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

  >> 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

What if you proceed step by step: you first locate the global maximum, process if needed the surrounding points given their value, then set the found region to zero, and repeat for the next one.





python variables declaration