पायथन * वास्तव में * में डिफ़ॉल्ट टुकड़ा सूचकांक क्या हैं?

Question

अजगर प्रलेखन docs.python.org/tutorial/introduction.html#strings से:

स्लाइस सूचकांक उपयोगी चूक है; एक छोड़ा गया पहला सूचकांक शून्य पर डिफ़ॉल्ट होता है, एक छोड़ी गई दूसरी अनुक्रमणिका स्ट्रिंग के आकार के लिए डिफ़ॉल्ट होती है।

>>> s = 'mystring' 
>>> s[1:] 
'ystring' 
>>> s[:3] 
'mys' 
>>> s[:-2] 
'mystri' 
>>> s[-1:] 
'g' 
>>> 

अब तक तो अच्छा:

मानक मामले के लिए, यह भावना का एक बहुत बनाता है। हालांकि, एक नकारात्मक कदम मूल्य का उपयोग कर थोड़ा अलग चूक सुझाव देने के लिए लगता है:

>>> s[:3:-1] 
'gnir' 
>>> s[0:3:-1] 
'' 
>>> s[2::-1] 
'sym' 

ठीक है, शायद अगर कदम नकारात्मक है, चूक रिवर्स। स्ट्रिंग के आकार के एक लोप पहले सूचकांक चूक शून्य करने के लिए कटा हुआ जा रहा है, एक छोड़े गए दूसरे सूचकांक चूक:

>>> s[len(s):3:-1] 
'gnir' 

अच्छा लग रहा है!

>>> s[2:0:-1] 
'sy' 

व्हाउप्स। याद किया कि 'एम'।

फिर हर कोई पसंदीदा स्ट्रिंग रिवर्स स्टेटमेंट है। और मीठा है:

>>> s[::-1] 
'gnirtsym' 

हालांकि:

>>> s[len(s):0:-1] 
'gnirtsy' 

टुकड़ा कभी नहीं टुकड़ा में दूसरा सूचकांक का मूल्य भी शामिल है। मैं इसे इस तरह से करने की स्थिरता देख सकता हूं।

तो मुझे लगता है कि मैं अपने विभिन्न क्रमपरिवर्तनों में टुकड़ा के व्यवहार को समझना शुरू कर रहा हूं। हालांकि, मुझे यह महसूस हो रहा है कि दूसरी अनुक्रमणिका कुछ खास है, और नकारात्मक चरण के लिए दूसरी अनुक्रमणिका का डिफ़ॉल्ट मान वास्तव में किसी संख्या के संदर्भ में परिभाषित नहीं किया जा सकता है।

क्या कोई भी डिफॉल्ट स्लाइस इंडेक्स को संक्षेप में परिभाषित कर सकता है जो प्रदान किए गए उदाहरणों के लिए खाता कर सकता है? दस्तावेज़ीकरण एक बड़ा प्लस होगा।

Answer 1

वहाँ वास्तव में किसी भी चूक कर रहे हैं; छोड़े गए मान विशेष रूप से इलाज किए जाते हैं।

हालांकि, हर मामले में, छोड़े गए मानों का बिल्कुल वैसा ही व्यवहार नहीं होता है। इसका मतलब है कि, जब तक आप दुभाषिया हैकिंग (या parser, ast, आदि मॉड्यूल का उपयोग कर रहे हैं), तो आप केवल यह दिखा सकते हैं कि डिफ़ॉल्ट कोई नहीं है (जैसा कि रिकर्सिव का जवाब कहता है), और आपको हमेशा सही उत्तर मिलेंगे।

उद्धृत अनौपचारिक दस्तावेज काफी सटीक नहीं है - जो किसी ट्यूटोरियल का हिस्सा बनने के लिए उचित है। वास्तविक उत्तरों के लिए, आपको संदर्भ दस्तावेज को चालू करना होगा।

2.7.3 के लिए, Sequence Types नोट 3, 4 में टुकड़ा करने की क्रिया का वर्णन करता है, और 5.

[i:j] के लिए:

... तो मैं छोड़ दिया जाता है या None, 0 का उपयोग करें। यदि जे छोड़ा गया है या None है, तो len(s) का उपयोग करें।

और [i:j:k] के लिए:

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

3.3, Sequence Types के लिए सटीक वही शब्द 2.7.3 है। यदि आप __getslice__ कार्यान्वित कर रहे हैं

Answer 2

reference documentation for sequence types में नोटों कुछ विस्तार से इस बताते हैं:

(5.) कदम कश्मीर साथ मैंजे करने से रों का टुकड़ा के अनुक्रम के रूप में परिभाषित किया गया है इंडेक्स x = i + n*k जैसे आइटम 0 <= n < (j-i)/k। दूसरे शब्दों में, सूचकांक i, i+k, i+2*k, i+3*k हैं और इतने पर, रोक जब जे (लेकिन कभी जे सहित) तक पहुँच जाता है। यदि i या jlen(s) से अधिक है, तो len(s) का उपयोग करें। यदि i या j छोड़े गए हैं या None, वे "अंत" मान बन जाते हैं (जो अंत के के संकेत पर निर्भर करता है)।नोट, के शून्य नहीं हो सकता है। यदि केNone है, तो यह 1 जैसा माना जाता है।

तो आप निम्न व्यवहार प्राप्त कर सकते हैं:

>>> s = "mystring" 
>>> s[2:None:-1] 
'sym' 

Answer 3

मैं किसी भी दस्तावेज नहीं है, लेकिन मुझे लगता है कि डिफ़ॉल्ट [None:None:None]

>>> "asdf"[None:None:None] 
'asdf' 
>>> "asdf"[None:None:-1] 
'fdsa' 

Answer 4

वास्तव में यह तार्किक है है ...

यदि आप अंतिम मान को देखते हैं, तो यह हमेशा अंतिम सूचकांक के बाद सूचकांक को इंगित करता है। तो, 0 का उपयोग अंतिम मान के रूप में करते हैं, इसका मतलब है कि यह इंडेक्स 1 पर तत्व तक हो जाता है। इसलिए, आपको उस मान को छोड़ना होगा .. ताकि वह इच्छित स्ट्रिंग लौटा सके।

>>> s = '' 
>>> s[0], s[:0] 
('0', '') 
>>> s[1], s[:1] 
('1', '0') 
>>> s[2], s[:2] 
('2', '01') 
>>> s[3], s[:3] 
('3', '012') 
>>> s[0], s[:0:-1] 
('0', '987654321') 

Answer 5

अंत मान हमेशा अनन्य, इस प्रकार 0 अंत मूल्य का मतलब है 1 सूचकांक लेकिन इसके बजाय 0. उपयोग कोई भी नहीं शामिल है (के बाद से नकारात्मक संख्या भिन्न अर्थ हो):

>>> s[len(s)-1:None:-1] 
'gnirtsym' 

नोट प्रारंभ मूल्य भी; अंतिम वर्ण सूचकांक len(s) - 1 पर है; आप के रूप में अच्छी वर्तनी हो सकता है कि के रूप में -1 (ऋणात्मक संख्या के रूप लंबाई के सापेक्ष व्याख्या कर रहे हैं):

>>> s[-1:None:-1] 
'gnirtsym' 

Answer 6

उपयोगी पता करने के लिए: करने के लिए sys.maxsize (https://docs.python.org/2/reference/datamodel.html#object.getslice)

>>> class x(str): 
... def __getslice__(self, i, j): 
...  print i 
...  print j 
... 
... def __getitem__(self, key): 
...  print repr(key) 
... 
>>> x()[:] 
0 
9223372036854775807 
>>> x()[::] 
slice(None, None, None) 
>>> x()[::1] 
slice(None, None, 1) 
>>> x()[:1:] 
slice(None, 1, None) 
>>> import sys 
>>> sys.maxsize 
9223372036854775807L