कैसे रिवर्स करने के लिए स्ट्रिंग का उपयोग कर सूची अजगर

निश्चित रूप से जानने के द्वारा, यह क्या करता है, आप समझ सकते हैं कोड । में while पाश, index मूल्य से शुरू होता है के अंत में स्ट्रिंग और नीचे की गिनती करने के लिए 0. प्रत्येक चरण में, यह कहते हैं कि चरित्र (फिर से शुरू, अंत) के अंत करने के लिए सूची का निर्माण है. अंत में, यह को जोड़ती है सूची में एक स्ट्रिंग.

तो, 'एबीसीडी', इस सूची में हो जाता है बनाया:

'abcd'  #3 -> ['d']
'abcd'  #2 -> ['d','c']
'abcd'  #1 -> ['d','c','b']
'abcd'  #0 -> ['d','c','b','a']

मूल रूप से ठीक है, इस स्ट्रिंग की लंबाई के साथ len विधि । जाएगा जो बदले में आप एक पूर्णांक मान का प्रतिनिधित्व कैसे लंबे समय है कि स्ट्रिंग है.

वे का उपयोग करें तो इस स्ट्रिंग की लंबाई और प्रभावी ढंग से पुनरावृति करने के लिए नीचे शून्य में एक while पाश । का उपयोग कर -= ऑपरेटर.

प्रत्येक यात्रा (जिसका अर्थ है प्रत्येक समय पाश के आसपास) यह से दूर ले जाएगा की लंबाई जब तक यह शून्य तक पहुँच जाता है.

तो चलो का उपयोग करें hello एक उदाहरण के रूप में इनपुट और इस के माध्यम से जाना ।

reverse_string('hello') है कि कैसे हम होता है, विधि फोन में किया print बयान के अपने कोड.

हम तो दर्ज समारोह और इन चरणों का पालन:

1. हम बनाने के लिए एक नया खाली सरणी कहा जाता है new_strings.
2. हम लंबाई को खोजने के प्रारंभिक स्ट्रिंग hello जो हमें देता है 5. जिसका अर्थ है कि अब index 5 के बराबर है.
3. हम बनाने के लिए एक जबकि पाश है कि जा रहा पर रहता है जब तक index कोई और अधिक का उपयोग कर while(index): - एक जबकि पाश इस तरह व्यवहार करता है एक 0 मूल्य के रूप में falsy और समाप्त हो जाएगा तक पहुँचने पर । इसलिए जब index है 0 पाश बंद हो जाएगा.
4. पहली पंक्ति के पाश निष्पादित करता है index -= 1 जो एक ही है के रूप में लेखन index = index - 1 तो बहुत पहले पाश के माध्यम से, हम प्राप्त index = 5 - 1 और तो अब index करने के लिए बराबर है 4.
5. क्योंकि अजगर देता है तो हमें का उपयोग character के एक स्ट्रिंग का उपयोग कर string[index] (और इस वजह से काम करता है 0 -> एन) प्रदर्शन hello[4] वास्तव में हमें देने के चरित्र o.
6. हम भी संलग्न इस चरित्र सरणी के लिए new_strings जिसका अर्थ है कि के रूप में हम के माध्यम से जाने के पुनरावृत्तियों तक पहुँचने के लिए यह शून्य जोड़ देगा प्रत्येक चरित्र के पीछे की ओर करने के लिए इस सरणी दे रही है हमें ['o', 'l', 'l', 'e', 'h']
7. के बाद से सूचकांक है, अब हम शून्य छोड़ पाश प्रदर्शन और एक join ऑपरेशन पर सरणी के लिए अभी तक फिर से बनाने के लिए एक स्ट्रिंग है. आदेश ''.join(new_strings) इसका मतलब है कि हम में शामिल करना चाहते हैं सरणी, हम पहले किया था के बिना एक विभाजक. अगर हम किया था '#'.join(new_strings) हम बजाय मिल गया होता o#l#l#e#h के बजाय olleh.

मुझे आशा है कि इस सवाल का जवाब देता है आप कुछ स्पष्टता.

यकीन है, यह बहुत ही सरल कार्यक्रम है. आप होना चाहिए reffer स्ट्रिंग के तरीकों और स्ट्रिंग अनुक्रमण में अजगर प्राप्त करने के लिए स्पष्ट विचार है. मुझे यह समझाने में deatial.

प्रिंट(reverse_string('हैलो'))//प्रिंट समारोह बुला रहा है एक अन्य समारोह reverse_string गुजर रहा है और तर्क"नमस्ते".

डेफ reverse_string(स्ट्रिंग):// तर्क "नमस्ते" चर में संग्रहीत स्ट्रिंग में reverse_string समारोह.

**new_strings = []** // created a new empty list
**index = len(string)** // len function returns the length of the argument 
                           passed to the function. len("hello")=5 and assigned 
                           to index. index=5.

जबकि सूचकांक: // जबकि पाश exicute हालत जब तक मिल गलत है .इस उदाहरण के लिए, जब सूचकांक =0 है.में स्ट्रिंग का अनुक्रमण 0 से शुरू करें .के लिए उदाहरण है । स्ट्रिंग[0]=h,स्ट्रिंग[1]=ई,स्ट्रिंग[2]=एल,स्ट्रिंग[3]=एल,स्ट्रिंग[4]=हे.

    **index -= 1**  //Note the last letter 'o' is in string[4] and the len 
                      function returned 5 so we need to decrement index variable 
                      to 4 so that it will pointing to string[4]=o                     
  

new_strings.संलग्न(स्ट्रिंग[सूचकांक]) // संलग्न स्ट्रिंग[4] है कि हे,,, और इतने पर ... वापसी ".में शामिल होने(new_strings)