अजगर स्ट्रिंग कड़ी - श्रृंखलाबद्ध '\ n'

Question

मैं अजगर करने के लिए नया हूँ और दोनों समस्याओं मैं श्रृंखलाबद्ध तार से संबंधित हो रही है समझने की कोशिश कर मदद की जरूरत है। मुझे पता है कि स्ट्रिंग को एक दूसरे के साथ + प्रतीक का उपयोग करके जोड़ा जा सकता है।

>>> 'a' + 'b' 
'ab' 

हालांकि, मैं अभी हाल ही में पता चला आप भी (/ लगभग नगण्य दुर्घटना से) तार जोड़ लिए + प्रतीक का उपयोग करने की जरूरत नहीं है, जो मेरी पहली समस्या की ओर जाता है समझने के लिए - कैसे/क्यों यह संभव है !?

>>> print 'a' + 'b' 
ab 

इसके अलावा, मैं यह भी समझता हूं कि '\ n' स्ट्रिंग 'न्यूलाइन' बनाती है। लेकिन जब मेरी पहली समस्या के साथ संयोजन में प्रयोग किया जाता है। मुझे निम्नलिखित मिलते हैं।

>>> print '\n' 'a'*7 

a 
a 
a 
a 
a 
a 
a 

तो मेरी दूसरी समस्या पैदा होती है - "मैं क्यों पत्र 'एक' दूसरे शब्दों में, नहीं पुनरावर्तक प्रतीक, *, पत्र 'एक' 7 बार दोहराना है की 7 नई लाइनों मिलता है।! ? के रूप में इस प्रकार है

>>> print 'a'*7 
aaaaaaa 

कृपया मेरी मदद स्पष्ट क्या चल रहा है

Answer 1

अजगर एक साथ तार संयोजित करता जब आप उन्हें अल्पविराम से पृथक नहीं है:।।

>>> print 'a' 'b' 
ab 

>>> print 'a', 'b' 
a b 

तो आप वास्तव में '\na' 7 बार प्रिंट कर रहे हैं।

Answer 2

जब "a" "b""ab" में बदल गया है, तो यह + के साथ स्ट्रिंग को संयोजित करने जैसा ही नहीं है। जब पाइथन स्रोत कोड पढ़ा जा रहा है, आसन्न तार स्वचालित रूप से सुविधा के लिए शामिल हो जाते हैं।

यह सामान्य ऑपरेशन नहीं है, यही कारण है कि यह + और * के लिए अपेक्षित संचालन के क्रम का पालन नहीं कर रहा है।

print '\n' 'a'*7 

वास्तव में

रूप में एक ही व्याख्या की है

print '\na'*7 

और नहीं

print '\n' + 'a'*7 

Answer 3

1. मुझे यकीन है कि तुम क्या मतलब है नहीं कर रहा हूँ के रूप में द्वारा "कैसे यह संभव है" । आप एक नियम लिखते हैं: एक दूसरे के बगल में दो तार मिलते हैं। फिर आप इसे पार्सर में कार्यान्वित करते हैं। क्यूं कर? क्योंकि यह आपको आसानी से इस तरह की चीजों को करने की अनुमति देता है:

   re.findall('(<?=(foo))' # The first part of a complicated regexp 
         '>asdas s'  # The next part 
         '[^asd]'  # The last part 
        ) 
   

   इस तरह, आप बस जो भी कर रहे हैं उसका वर्णन कर सकते हैं।

2. जब आप एक * बी + सी करते हैं, कंप्यूटर हमेशा एक बार बी पहले, तो सी कहते हैं करता है, क्योंकि गुणा इसके पहले आता है।

   जब आप एक-दूसरे के आगे स्ट्रिंग अक्षर डालकर स्ट्रिंग कॉन्सटेनेशन करते हैं, और गुणा, विशेष स्ट्रिंग कॉन्सटेनेशन पहले आता है। इसका मतलब है '\n' 'a' * 7('\n' 'a') * 7 जैसा ही है, इसलिए आप जिस स्ट्रिंग को दोहरा रहे हैं वह '\na' है।

Answer 4

आप शायद पहले ही महसूस कर चुके हैं कि आसन्न तारों के निहित समापन पर निर्भर कभी-कभी समस्याग्रस्त होता है। इसके अलावा, + ऑपरेटर के साथ संगत नहीं है। यह केवल ध्यान देने योग्य नहीं है अगर केवल कुछ छोटे तारों में शामिल हो, लेकिन यह पैमाने पर बहुत ही ध्यान देने योग्य है।

इसके बारे में स्पष्ट रहें; का उपयोग ''.join()

print '\n'.join(['a'*7])