अजगर

Question

में एक स्ट्रिंग मैं एक तरह से पीछे की ओर एक स्ट्रिंग मुद्रित करने के लिए के लिए देख रहा था रिवर्स, और गूगल पर एक त्वरित खोज के बाद, मैं इस विधि पाया:

मान लीजिए 'एक' एक स्ट्रिंग चर रहा है। यह 'ए' स्ट्रिंग को पीछे की ओर लौटाएगा:

a[::-1] 

क्या कोई यह बता सकता है कि यह कैसे काम करता है?

Answer 1

ज़रूर, [::]extended slice ऑपरेटर है। यह आप की अनुमति देता है सबस्ट्रिंग लेने के लिए। मूल रूप से, यह निर्दिष्ट करता है कि आप कौन से तत्व चाहते हैं [प्रारंभ: अंत: चरण], और यह सभी अनुक्रमों के लिए काम करता है। इसके बारे में दो साफ चीजें:

• आप एक या तत्वों की अधिक छोड़ सकते हैं और यह "सही बात"
• ऋणात्मक संख्याओं को शुरू करते हैं, अंत के लिए करता है, और कदम

अर्थ है के लिए शुरू करते हैं और अंत में, यदि आप एक नकारात्मक नंबर दे , इसका मतलब अनुक्रम के अंत से गिनना है।उदाहरण के लिए, अगर मैं एक सूची है:

l = [1,2,3] 

फिर 2 है, और l[-3] 1.

step तर्क के लिए, एक नकारात्मक संख्या के माध्यम से पीछे की ओर काम करने का मतलब है अनुक्रम। एक सूची के लिए तो ::

l = [1,2,3,4,5,6,7,8,9,10] 

आप l[::-1] लिख सकता है मूल रूप से की -1 एक कदम आकार का उपयोग करने के सूची के माध्यम से पढ़ते समय जिसका मतलब है। शुरुआत में भरते समय पाइथन "सही काम करेगा" और बंद होने के बाद यह सूची को पीछे की ओर चलाता है और आपको [10,9,8,7,6,5,4,3,2,1] देता है।

मैंने सूचियों के साथ उदाहरण दिए हैं, लेकिन तार सिर्फ एक और अनुक्रम हैं और वैसे ही काम करते हैं। तो a[::-1] स्ट्रिंग के माध्यम से पीछे की तरफ चलने वाले पात्रों में शामिल होने से स्ट्रिंग बनाने का मतलब है।

Answer 2

यह अजगर में स्लाइस संकेतन कहा जाता है और आप कैसे इसे यहाँ काम करता है की एक थोड़ा और अधिक पढ़ सकते हैं:

Explain Python's slice notation

Answer 3

यह extended slice notation है:

sequence[start:end:step] 

इस मामले में, कदम -1 पीछे की ओर का मतलब है, और शुरुआत और अंत को छोड़ने का मतलब है कि आप पूरी स्ट्रिंग चाहते हैं।

Answer 4

"-1" भाग स्लाइसिंग के "चरण" भाग का प्रतिनिधित्व करता है-इस मामले में, यह एक समय में स्ट्रिंग 1 वर्ण के माध्यम से जाता है, लेकिन पीछे (एक नकारात्मक चरण स्ट्रिंग के अंत से शुरू होता है) । यदि आप चरण 2 निर्दिष्ट करते हैं, उदाहरण के लिए, आपको स्ट्रिंग के हर दूसरे चरित्र को पहले से शुरू किया जाएगा। यदि आप -2 का चरण निर्दिष्ट करते हैं, तो आपको अंतिम चरित्र से शुरू होने और पीछे की ओर काम करने, स्ट्रिंग के हर दूसरे चरित्र मिलेंगे।

तो, संक्षेप में, a = '12345' यदि:

• a[::2] हो जाता है 135
• a[::-1]54321
• a[::-2] हो जाता हो जाता है 531

Answer 5

यह विस्तारित टुकड़ा करने की क्रिया का उपयोग कर रहा है - एक स्ट्रिंग एक दृश्य है पायथन में, और अन्य अनुक्रमों के साथ कुछ तरीकों को साझा करता है (na माली सूचियों और tuples)। स्लाइसिंग के लिए तीन भाग हैं - शुरू करें, रोकें और चरणबद्ध करें। उनमें से सभी के पास डिफ़ॉल्ट मान हैं - 0 से डिफ़ॉल्ट शुरू करें, लेन (अनुक्रम) के लिए डिफ़ॉल्ट को रोकें, और चरण 1 को डिफ़ॉल्ट करें। [:: - 1] निर्दिष्ट करके आप "अनुक्रम में सभी तत्व शुरुआत से शुरू करते हैं , अंत में एक समय में पिछड़े एक जा रहा है।

यह सुविधा अजगर 2.3.5 में पेश किया गया था, और आप What's New docs में और अधिक पढ़ सकते हैं।

Answer 6

[:: - 1] स्ट्रिंग ए का एक टुकड़ा देता है। पूर्ण वाक्यविन्यास a[begin:end:step] है जो एक [प्रारंभ], एक [प्रारंभ + चरण], ... एक [अंत -1] देता है। जब कदम नकारात्मक होता है, तो आप अंत में शुरू होते हैं और शुरू करने के लिए आगे बढ़ते हैं।

अंत में, अनुक्रम की शुरुआत, अंत तक अंत, और चरण -1 तक डिफ़ॉल्ट शुरू करें।

Answer 7

एक स्ट्रिंग अनिवार्य रूप से वर्णों का अनुक्रम है और इसलिए स्लाइसिंग ऑपरेशन इस पर काम करता है। आप वास्तव में क्या कर रहे हैं वास्तव में:

-> 1 पिछड़े के चरणों में शुरू से 'ए' का एक टुकड़ा प्राप्त करें।

Answer 8

मुझे लगता है कि निम्नलिखित रिवर्स में प्रिंट स्ट्रिंग्स के लिए थोड़ा अधिक समझ में आता है, लेकिन शायद यह है कि सिर्फ मुझे है:

for char in reversed(myString): 
    print(char, end = "") 

Answer 9

मैं इस तरह यह करना होगा:

variable = "string" 
message = "" 
for b in variable: 
    message = b+message 
print (message) 

और यह प्रिंट: gnirts

Answer 10

नीचे दी गई सूची पर विचार करें

l=[12,23,345,456,67,7,945,467] 

एक सूची को पलटने के लिए एक और चाल हो सकती है:

l[len(l):-len(l)-1:-1] [467, 945, 7, 67, 456, 345, 23, 12] 

l[:-len(l)-1:-1] [467, 945, 7, 67, 456, 345, 23, 12] 

l[len(l)::-1] [467, 945, 7, 67, 456, 345, 23, 12] 

Answer 11

हम संलग्न का उपयोग करें और यह करने के लिए पॉप कर सकते हैं

def rev(s): 
    i = list(s) 
    o = list() 
    while len(i) > 0: 
     o.append(t.pop()) 

    return ''.join(o) 

Answer 12

यह बुनियादी कदम अंकन, की कार्यक्षमता पर विचार कर रहा है:

एक [ 2: 4: 2]

स्थिति 2 और 4 के बीच सूचकांक काट दिया जाता है, तीसरा चर क्या करता है यह चरण चरण से शुरू होता है पहला मूल्य इस मामले में यह एक [2] वापस कर देगा, क्योंकि एक [4] ऊपरी सीमा है केवल दो मान वापस आते हैं और कोई दूसरा कदम नहीं होता है। (-) शून्य ऑपरेटर बस चरण आउटपुट को उलट देता है।

Answer 13

बिना उलट का उपयोग कर या [:: - 1], यहां एक सरल प्रत्यावर्तन के आधार पर संस्करण मैं सबसे पठनीय होने के लिए विचार किया जाएगा है:

def reverse(s): 

    if len(s)==2: 
    return s[-1] + s[0] 

    if len(s)==1: 
    return s[0] 

    return s[-1] + reverse(s[1:len(s)-1]) + s[0]