टुकड़ा धारणा को समझना

Question

मुझे पायथन के स्लाइस अंकन पर एक अच्छी व्याख्या (संदर्भ एक प्लस) की आवश्यकता है।

मेरे लिए, इस अंकन को थोड़ा ऊपर उठाने की जरूरत है।

यह बहुत शक्तिशाली दिखता है, लेकिन मुझे इसके चारों ओर अपना सिर नहीं मिला है।

Answer 1

यह वास्तव में बहुत आसान है:

a[start:stop]  # items start through stop-1
a[start:]      # items start through the rest of the array
a[:stop]       # items from the beginning through stop-1
a[:]           # a copy of the whole array

stepमूल्य भी है , जिसका उपयोग उपरोक्त में से किसी के साथ किया जा सकता है:

a[start:stop:step] # start through not past stop, by step

याद रखने के लिए महत्वपूर्ण बिंदु यह है कि :stopमूल्य पहले मूल्य का प्रतिनिधित्व करता है जो चयनित स्लाइस में नहीं है। तो, के बीच का अंतर stopऔर startचयनित तत्वों की संख्या है (यदि step1 है, तो डिफ़ॉल्ट)।

अन्य विशेषता यह है कि है startया stopएक हो सकता है नकारात्मक संख्या है, जो साधन यह शुरुआत के बजाय सरणी के अंत से गिना जाता है। इसलिए:

a[-1]    # last item in the array
a[-2:]   # last two items in the array
a[:-2]   # everything except the last two items

इसी तरह, stepएक ऋणात्मक संख्या हो सकती है:

a[::-1]    # all items in the array, reversed
a[1::-1]   # the first two items, reversed
a[:-3:-1]  # the last two items, reversed
a[-3::-1]  # everything except the last two items, reversed

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

slice()वस्तु से संबंध

स्लाइसिंग ऑपरेटर []वास्तव में उपरोक्त कोड slice()में :नोटेशन का उपयोग करते हुए किसी वस्तु के साथ किया जा रहा है (जो कि केवल मान्य है []), अर्थात:

a[start:stop:step]

के बराबर है:

a[slice(start, stop, step)]

स्लाइस ऑब्जेक्ट्स भी तर्कों की संख्या के आधार पर थोड़ा भिन्न व्यवहार करते हैं, इसी तरह range()दोनों अर्थात slice(stop)और slice(start, stop[, step])समर्थित हैं। दिए गए तर्क को निर्दिष्ट करने के लिए, कोई भी उपयोग कर सकता है None, ताकि उदाहरण a[start:]के बराबर a[slice(start, None)]या a[::-1]के बराबर हो a[slice(None, None, -1)]।

जबकि :थ्रेडेड नोटेशन सरल स्लाइसिंग के लिए बहुत सहायक है, slice()वस्तुओं का स्पष्ट उपयोग स्लाइसिंग की प्रोग्रामेटिक पीढ़ी को सरल करता है।

Comments

स्लिंगिंग बिलिन प्रकार एक प्रति लौटाता है लेकिन यह सार्वभौमिक नहीं है। विशेष रूप से, NumPy सरणियों का टुकड़ा करना एक ऐसा दृश्य देता है जो स्मृति को मूल के साथ साझा करता है।

— बेनी चेर्नियाव्स्की-पास्किन

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

— मार्क रैनसम

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

— axell13

और मुझे पता है कि "abcdef" [:: - 1] "abcdef" [6: -7: -1] में तब्दील हो गया है, इसलिए समझाने का सबसे अच्छा तरीका होगा: लेन को अनुक्रम की लंबाई होने दें । यदि चरण सकारात्मक है , तो शुरुआत और अंत के लिए चूक 0 और लेन हैं । अधिक अगर कदम नकारात्मक है , तो शुरुआत और अंत के लिए चूक लेन और - लेन हैं - 1.

— axell13

जबसे stackoverflow.com/questions/39241529/… को इस बात का delपता लगाया जाता है, कि क्या यह उस खंड को जोड़ने के लिए समझ में आएगा जो wrt slice संकेतन करता है। विशेष रूप से, del arr[:]तुरंत स्पष्ट नहीं है ("गिरफ्तार [:] एक प्रतिलिपि बनाता है, इसलिए डेल उस प्रतिलिपि को हटा देता है ???" आदि)

— khazhyk

Answer 2

अजगर ट्यूटोरियल इसके बारे में बात करती है (एक बिट तक नीचे स्क्रॉल टुकड़ा करने की क्रिया के बारे में हिस्सा करने के लिए मिल)।

स्लाइस कैसे काम करती है, यह याद रखने के लिए ASCII कला आरेख सहायक है:

 +---+---+---+---+---+---+
 | P | y | t | h | o | n |
 +---+---+---+---+---+---+
 0   1   2   3   4   5   6
-6  -5  -4  -3  -2  -1

यह याद रखने का एक तरीका है कि सूचकांकों को इंगित करने के लिए स्लाइस कैसे काम करता है पात्रों के बीच , पहले चरित्र के बाएं किनारे के साथ 0. है फिर एक स्ट्रिंग एन अक्षर के अंतिम चरित्र के दाहिने किनारे पर सूचकांक n है ।

Comments

यह सुझाव सकारात्मक प्रगति के लिए काम करता है, लेकिन नकारात्मक प्रगति के लिए नहीं। आरेख से, मैं होने की उम्मीद a[-4,-6,-1]करता हूं yPलेकिन यह है ty। हमेशा जो काम पात्रों या स्लॉट्स में सोचते हैं और एक आधे-खुले अंतराल के रूप में अनुक्रमण का उपयोग करते हैं - यदि सकारात्मक स्ट्राइड, बाएं-ओपन, तो नकारात्मक स्ट्राइड।

— अगुआदोप

लेकिन अंत से शुरू होने वाले एक खाली सेट के ढहने का कोई तरीका नहीं है (जैसे x[:0]शुरुआत से शुरू होता है), इसलिए आपको विशेष-छोटे छोटे सरणियों का सामना करना पड़ता है। : /

— एंडोलिथ

Answer 3

व्याकरण द्वारा अनुमत संभावनाओं की गणना:

>>> seq[:]                # [seq[0],   seq[1],          ..., seq[-1]    ]
>>> seq[low:]             # [seq[low], seq[low+1],      ..., seq[-1]    ]
>>> seq[:high]            # [seq[0],   seq[1],          ..., seq[high-1]]
>>> seq[low:high]         # [seq[low], seq[low+1],      ..., seq[high-1]]
>>> seq[::stride]         # [seq[0],   seq[stride],     ..., seq[-1]    ]
>>> seq[low::stride]      # [seq[low], seq[low+stride], ..., seq[-1]    ]
>>> seq[:high:stride]     # [seq[0],   seq[stride],     ..., seq[high-1]]
>>> seq[low:high:stride]  # [seq[low], seq[low+stride], ..., seq[high-1]]

बेशक, अगर (high-low)%stride != 0, तो अंत बिंदु की तुलना में थोड़ा कम होगा high-1।

यदि strideऋणात्मक है, तो क्रम को थोड़ा बदल दिया जाता है क्योंकि हम नीचे की गिनती कर रहे हैं:

>>> seq[::-stride]        # [seq[-1],   seq[-1-stride],   ..., seq[0]    ]
>>> seq[high::-stride]    # [seq[high], seq[high-stride], ..., seq[0]    ]
>>> seq[:low:-stride]     # [seq[-1],   seq[-1-stride],   ..., seq[low+1]]
>>> seq[high:low:-stride] # [seq[high], seq[high-stride], ..., seq[low+1]]

विस्तारित स्लाइसिंग (अल्पविराम और दीर्घवृत्त के साथ) का उपयोग केवल विशेष डेटा संरचनाओं (जैसे कि NumPy) द्वारा किया जाता है; मूल क्रम उनका समर्थन नहीं करते हैं।

>>> class slicee:
...     def __getitem__(self, item):
...         return repr(item)
...
>>> slicee()[0, 1:2, ::5, ...]
'(0, slice(1, 2, None), slice(None, None, 5), Ellipsis)'

Comments

वास्तव में अभी भी कुछ बचा हुआ है जैसे अगर मैं 'ऐप्पल' टाइप करता हूँ [4: -4: -1] तो मुझे 'एल्प' मिलता है, अजगर शायद -4 को 1 में अनुवाद कर रहा है?

— लियुआन

ध्यान दें कि repr

— बैकटिक्स के

@ एलयुआन लागू करने __getitem__का प्रकार है; आपके उदाहरण के बराबर है apple[slice(4, -4, -1)]।

— शेपनर

Answer 4

ऊपर दिए गए उत्तर स्लाइस असाइनमेंट पर चर्चा नहीं करते हैं। स्लाइस असाइनमेंट को समझने के लिए, ASCII कला में एक और अवधारणा जोड़ना उपयोगी है:

                +---+---+---+---+---+---+
                | P | y | t | h | o | n |
                +---+---+---+---+---+---+
Slice position: 0   1   2   3   4   5   6
Index position:   0   1   2   3   4   5

>>> p = ['P','y','t','h','o','n']
# Why the two sets of numbers:
# indexing gives items, not lists
>>> p[0]
 'P'
>>> p[5]
 'n'

# Slicing gives lists
>>> p[0:1]
 ['P']
>>> p[0:2]
 ['P','y']

शून्य से n तक के एक स्लाइस के लिए, एक अनुमान है: "शून्य शुरुआत है, शुरुआत में शुरू करें और सूची में n आइटम लें"।

>>> p[5] # the last of six items, indexed from zero
 'n'
>>> p[0:5] # does NOT include the last item!
 ['P','y','t','h','o']
>>> p[0:6] # not p[0:5]!!!
 ['P','y','t','h','o','n']

एक अन्य अनुमानी है, "किसी भी स्लाइस के लिए, शुरुआत को शून्य से बदलें, सूची के अंत को प्राप्त करने के लिए पिछले अनुमान को लागू करें, फिर शुरुआत से पहले आइटम को चॉप करने के लिए पहले नंबर की गिनती करें"

>>> p[0:4] # Start at the beginning and count out 4 items
 ['P','y','t','h']
>>> p[1:4] # Take one item off the front
 ['y','t','h']
>>> p[2:4] # Take two items off the front
 ['t','h']
# etc.

स्लाइस असाइनमेंट का पहला नियम यह है कि चूंकि स्लाइसिंग एक सूची देता है, स्लाइस असाइनमेंट के लिए एक सूची (या अन्य चलने योग्य) की आवश्यकता होती है:

>>> p[2:3]
 ['t']
>>> p[2:3] = ['T']
>>> p
 ['P','y','T','h','o','n']
>>> p[2:3] = 't'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: can only assign an iterable

स्लाइस असाइनमेंट का दूसरा नियम, जिसे आप ऊपर भी देख सकते हैं, वह यह है कि सूची का जो भी भाग स्लाइस इंडेक्सिंग द्वारा लौटाया गया है, वह वही भाग है जिसे स्लाइस असाइनमेंट द्वारा बदल दिया गया है:

>>> p[2:4]
 ['T','h']
>>> p[2:4] = ['t','r']
>>> p
 ['P','y','t','r','o','n']

स्लाइस असाइनमेंट का तीसरा नियम है, सौंपी गई सूची (पुनरावृत्ति) की लंबाई समान नहीं होनी चाहिए; अनुक्रमित टुकड़ा बस बाहर कटा हुआ है और जो कुछ भी सौंपा जा रहा है, उसके द्वारा उसे प्रतिस्थापित किया गया है:

>>> p = ['P','y','t','h','o','n'] # Start over
>>> p[2:4] = ['s','p','a','m']
>>> p
 ['P','y','s','p','a','m','o','n']

खाली स्लाइस को असाइन करने के लिए उपयोग किया जाने वाला पेचीदा हिस्सा। हेयिस्टिक 1 और 2 का उपयोग करना आपके सिर को खाली स्लाइस को इंडेक्स करने में आसान बनाता है :

>>> p = ['P','y','t','h','o','n']
>>> p[0:4]
 ['P','y','t','h']
>>> p[1:4]
 ['y','t','h']
>>> p[2:4]
 ['t','h']
>>> p[3:4]
 ['h']
>>> p[4:4]
 []

और फिर एक बार आपने देखा है कि, खाली स्लाइस को स्लाइस असाइनमेंट भी समझ में आता है:

>>> p = ['P','y','t','h','o','n']
>>> p[2:4] = ['x','y'] # Assigned list is same length as slice
>>> p
 ['P','y','x','y','o','n'] # Result is same length
>>> p = ['P','y','t','h','o','n']
>>> p[3:4] = ['x','y'] # Assigned list is longer than slice
>>> p
 ['P','y','t','x','y','o','n'] # The result is longer
>>> p = ['P','y','t','h','o','n']
>>> p[4:4] = ['x','y']
>>> p
 ['P','y','t','h','x','y','o','n'] # The result is longer still

ध्यान दें कि, चूंकि हम स्लाइस (4) की दूसरी संख्या को नहीं बदल रहे हैं, सम्मिलित वस्तुएं हमेशा 'ओ' के खिलाफ खड़ी होती हैं, तब भी जब हम खाली स्लाइस को असाइन कर रहे होते हैं। तो खाली स्लाइस असाइनमेंट के लिए स्थिति गैर-खाली स्लाइस असाइनमेंट के लिए पदों का तार्किक विस्तार है।

थोड़ा सा समर्थन करते हुए, क्या होता है जब आप स्लाइस की शुरुआत की गिनती के हमारे जुलूस के साथ जाते रहते हैं?

>>> p = ['P','y','t','h','o','n']
>>> p[0:4]
 ['P','y','t','h']
>>> p[1:4]
 ['y','t','h']
>>> p[2:4]
 ['t','h']
>>> p[3:4]
 ['h']
>>> p[4:4]
 []
>>> p[5:4]
 []
>>> p[6:4]
 []

स्लाइसिंग के साथ, एक बार हो जाने के बाद, आप कर रहे हैं; यह पीछे की ओर खिसकना शुरू नहीं करता है। जब तक आप स्पष्ट रूप से नकारात्मक संख्या का उपयोग करके उनके लिए नहीं पूछेंगे, पायथन में आपको नकारात्मक प्रगति नहीं मिलती है।

>>> p[5:3:-1]
 ['n','o']

"आप कर रहे हैं एक बार, आप कर रहे हैं" नियम के कुछ अजीब परिणाम हैं:

>>> p[4:4]
 []
>>> p[5:4]
 []
>>> p[6:4]
 []
>>> p[6]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: list index out of range

वास्तव में, अनुक्रमण की तुलना में, पायथन स्लाइसिंग विचित्र त्रुटि-प्रमाण है:

>>> p[100:200]
 []
>>> p[int(2e99):int(1e99)]
 []

यह कभी-कभी काम आ सकता है, लेकिन यह कुछ अजीब व्यवहार भी कर सकता है:

>>> p
 ['P', 'y', 't', 'h', 'o', 'n']
>>> p[int(2e99):int(1e99)] = ['p','o','w','e','r']
>>> p
 ['P', 'y', 't', 'h', 'o', 'n', 'p', 'o', 'w', 'e', 'r']

आपके आवेदन पर निर्भर करता है, कि ... या हो सकता है ... आप वहाँ के लिए क्या उम्मीद कर रहे थे!

---

नीचे मेरे मूल उत्तर का पाठ है। यह कई लोगों के लिए उपयोगी रहा है, इसलिए मैं इसे हटाना नहीं चाहता था।

>>> r=[1,2,3,4]
>>> r[1:1]
[]
>>> r[1:1]=[9,8]
>>> r
[1, 9, 8, 2, 3, 4]
>>> r[1:1]=['blah']
>>> r
[1, 'blah', 9, 8, 2, 3, 4]

यह टुकड़ा करने और अनुक्रमण के बीच के अंतर को भी स्पष्ट कर सकता है।

Answer 5

पायथन के स्लाइस अंकन की व्याख्या करें

संक्षेप में, कोलन ( :) सबस्क्रिप्ट अंकन में ( subscriptable[subscriptarg]) मेकअप टुकड़ा अंकन - जो वैकल्पिक तर्क हैं तो start, stop, step:

sliceable[start:stop:step]

पायथन स्लाइसिंग आपके डेटा के कुछ हिस्सों को व्यवस्थित रूप से एक्सेस करने का एक कम्प्यूटेशनल तेज़ तरीका है। मेरी राय में, यहां तक ​​कि एक मध्यवर्ती पायथन प्रोग्रामर होने के लिए, यह भाषा का एक पहलू है जिससे परिचित होना आवश्यक है।

महत्वपूर्ण परिभाषाएँ

शुरू करने के लिए, आइए कुछ शब्दों को परिभाषित करें:

प्रारंभ: स्लाइस की शुरुआत सूचकांक, इसमें इस सूचकांक में तत्व शामिल होगा जब तक कि यह स्टॉप के समान नहीं होता है , 0 पर चूक, यानी पहला सूचकांक। यदि यह नकारात्मक है, तो इसका मतलब nअंत से आइटम शुरू करना है।

स्टॉप: स्लाइस का अंत इंडेक्स, इसमें इस इंडेक्स में तत्व शामिल नहीं है , अनुक्रम की लंबाई को डिफॉल्ट किया जाता है, यानी अंत तक और सहित।

चरण: वह राशि जिसके द्वारा इंडेक्स बढ़ता है, डिफॉल्ट करता है 1. यदि यह नकारात्मक है, तो आप रिवर्स में चलने योग्य से अधिक इसे काट रहे हैं।

कैसे अनुक्रमण काम करता है

आप इनमें से कोई भी सकारात्मक या नकारात्मक संख्या बना सकते हैं। सकारात्मक संख्याओं का अर्थ सीधा है, लेकिन नकारात्मक संख्याओं के लिए, पायथन में अनुक्रमित की तरह, आप शुरुआत और स्टॉप के लिए अंत से पीछे की ओर गिनती करते हैं , और कदम के लिए , आप बस अपने सूचकांक को घटाते हैं। यह उदाहरण दस्तावेज़ीकरण के ट्यूटोरियल से है , लेकिन मैंने यह इंगित करने के लिए इसे थोड़ा संशोधित किया है कि कौन सी वस्तु प्रत्येक अनुक्रम संदर्भ में है:

 +---+---+---+---+---+---+
 | P | y | t | h | o | n |
 +---+---+---+---+---+---+
   0   1   2   3   4   5 
  -6  -5  -4  -3  -2  -1

स्लाइसिंग कैसे काम करती है

एक अनुक्रम के साथ टुकड़ा संकेतन का उपयोग करने के लिए जो इसे समर्थन करता है, आपको कम से कम एक कोष्ठक कोष्ठक में शामिल करना चाहिए जो अनुक्रम का अनुसरण करते हैं (जो वास्तव में है) __getitem__पाइथन डेटा मॉडल के अनुसार, अनुक्रम का में अनुक्रम की विधि को लागू करते हैं ।)

स्लाइस अंकन इस तरह काम करता है:

sequence[start:stop:step]

और याद रखें कि स्टार्ट , स्टॉप के लिए डिफॉल्ट हैं और स्टेप के लिए डिफॉल्ट हैं, इसलिए डिफॉल्ट को एक्सेस करने के लिए, बस तर्क को छोड़ दें।

अंतिम नौ तत्वों को एक सूची (या किसी अन्य अनुक्रम से जो इसे एक स्ट्रिंग की तरह समर्थन करता है) से प्राप्त करने के लिए स्लाइस अंकन इस तरह दिखेगा:

my_list[-9:]

जब मैं इसे देखता हूं, तो मैं कोष्ठक में भाग को "अंत से 9 वें, अंत तक" पढ़ता हूं। (वास्तव में, मैं इसे "-9, ऑन" के रूप में मानसिक रूप से संक्षिप्त करता हूं)

स्पष्टीकरण:

पूर्ण संकेतन है

my_list[-9:None:None]

और चूक को बदलने के लिए (वास्तव में जब stepनकारात्मक stopहै -len(my_list) - 1, तो डिफ़ॉल्ट है , इसलिए Noneवास्तव में रुकने के लिए इसका मतलब है कि जो भी अंतिम चरण में ले जाता है):

my_list[-9:len(my_list):1]

पेट , :, क्या अजगर आपको बताता है कि यह एक टुकड़ा और नहीं एक नियमित रूप से सूचकांक दे रहे है। यही कारण है कि पायथन 2 में सूचियों की उथली प्रतिलिपि बनाने का मुहावरेदार तरीका है

list_copy = sequence[:]

और उन्हें साफ़ करना है:

del my_list[:]

(अजगर 3 हो जाता है एक list.copyऔरlist.clear विधि विधि ।)

जब stepनकारात्मक है, के लिए चूक startऔरstop परिवर्तन

डिफ़ॉल्ट रूप से, जब stepतर्क खाली होता है (या None), इसे सौंपा जाता है+1 ।

लेकिन आप एक नकारात्मक पूर्णांक में पास कर सकते हैं, और सूची (या अधिकांश अन्य मानक स्लाबल्स) को अंत से शुरुआत तक कटा हुआ होगा।

इस प्रकार एक नकारात्मक टुकड़ा के लिए चूक बदल जाएगा startऔरstop !

स्रोत में इसकी पुष्टि करते हैं

मुझे उपयोगकर्ताओं को स्रोत के साथ-साथ प्रलेखन पढ़ने के लिए प्रोत्साहित करना पसंद है। टुकड़ा के लिए स्रोत कोड वस्तुओं और इस तर्क यहाँ पाया जाता है । पहले हम निर्धारित करते हैं कि stepक्या नकारात्मक है:

 step_is_negative = step_sign < 0;

यदि ऐसा है, तो निचली बाउंड का -1 अर्थ है कि हम शुरुआत और अंत तक सभी तरह से स्लाइस करते हैं, और ऊपरी बाउंड लंबाई माइनस 1 है, जिसका अर्थ है कि हम अंत में शुरू करते हैं। (ध्यान दें कि यह के शब्दों -1है अलग एक से -1है कि उपयोगकर्ताओं को पिछले आइटम का संकेत अजगर में अनुक्रमित पारित कर सकते हैं।)

if (step_is_negative) {
    lower = PyLong_FromLong(-1L);
    if (lower == NULL)
        goto error;

    upper = PyNumber_Add(length, lower);
    if (upper == NULL)
        goto error;
}

अन्यथा stepसकारात्मक है, और निचली सीमा शून्य होगी और ऊपरी बाउंड (जो हम ऊपर तक जाते हैं लेकिन शामिल नहीं हैं) कटा हुआ सूची की लंबाई।

else {
    lower = _PyLong_Zero;
    Py_INCREF(lower);
    upper = length;
    Py_INCREF(upper);
}

फिर, हमें डिफ़ॉल्ट को लागू करने की आवश्यकता हो सकती है startऔर stop- तब नकारात्मक startहोने पर ऊपरी सीमा के रूप में गणना की जाती stepहै:

if (self->start == Py_None) {
    start = step_is_negative ? upper : lower;
    Py_INCREF(start);
}

और stop, निम्न सीमा:

if (self->stop == Py_None) {
    stop = step_is_negative ? lower : upper;
    Py_INCREF(stop);
}

अपने स्लाइस को एक वर्णनात्मक नाम दें!

आप इसे स्लाइस को बनाने के लिए इसे list.__getitem__विधि से अलग करने के लिए उपयोगी पा सकते हैं ( यह वर्ग कोष्ठक करते हैं )। यहां तक ​​कि अगर आप इसके लिए नए नहीं हैं, तो यह आपके कोड को अधिक पठनीय रखता है, ताकि आपके कोड को पढ़ने वाले अन्य लोगों को आसानी से समझ सकें कि हम क्या कर रहे हैं।

हालाँकि, आप कॉलन द्वारा अलग किए गए कुछ पूर्णांकों को एक चर में निर्दिष्ट नहीं कर सकते। आपको स्लाइस ऑब्जेक्ट का उपयोग करने की आवश्यकता है:

last_nine_slice = slice(-9, None)

दूसरा तर्क, None, की आवश्यकता है, ताकि पहले तर्क के रूप में व्याख्या की है startतर्क अन्यथा यह होगा stopतर्क ।

फिर आप अपने अनुक्रम में स्लाइस ऑब्जेक्ट पास कर सकते हैं:

>>> list(range(100))[last_nine_slice]
[91, 92, 93, 94, 95, 96, 97, 98, 99]

यह दिलचस्प है कि पर्वतमाला भी स्लाइस लेती है:

>>> range(100)[last_nine_slice]
range(91, 100)

स्मृति संबंधी बातें:

चूंकि पायथन सूचियों के स्लाइस स्मृति में नई वस्तुओं का निर्माण करते हैं, इस बारे में जागरूक होने के लिए एक और महत्वपूर्ण कार्य है itertools.islice। आमतौर पर आप एक स्लाइस पर चलना चाहते हैं, न कि यह केवल स्मृति में सांख्यिकीय रूप से बनाया गया है। isliceइसके लिए एकदम सही है। एक चेतावनी है, यह करने के लिए नकारात्मक तर्क का समर्थन नहीं करता start, stopया step, कि यदि ऐसा है तो एक मुद्दा है आप सूचकांक की गणना या पहले से iterable उल्टा करने के लिए आवश्यकता हो सकती है।

length = 100
last_nine_iter = itertools.islice(list(range(length)), length-9, None, 1)
list_last_nine = list(last_nine_iter)

और अब:

>>> list_last_nine
[91, 92, 93, 94, 95, 96, 97, 98, 99]

तथ्य यह है कि सूची स्लाइस एक प्रति बनाते हैं खुद सूचियों की एक विशेषता है। यदि आप पंडों डेटाफ़्रेम की तरह उन्नत वस्तुओं का टुकड़ा कर रहे हैं, तो यह मूल पर एक दृश्य लौटा सकता है, न कि एक प्रति।

Answer 6

और कुछ चीजें जो तुरंत मेरे लिए स्पष्ट नहीं थीं जब मैंने पहली बार स्लाइसिंग सिंटैक्स देखा:

>>> x = [1,2,3,4,5,6]
>>> x[::-1]
[6,5,4,3,2,1]

दृश्यों को रिवर्स करने का आसान तरीका!

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

>>> x = [1,2,3,4,5,6]
>>> x[::-2]
[6,4,2]

Answer 7

पायथन 2.7 में

अजगर में कटाक्ष

[a:b:c]

len = length of string, tuple or list

c -- default is +1. The sign of c indicates forward or backward, absolute value of c indicates steps. Default is forward with step size 1. Positive means forward, negative means backward.

a --  When c is positive or blank, default is 0. When c is negative, default is -1.

b --  When c is positive or blank, default is len. When c is negative, default is -(len+1).

सूचकांक असाइनमेंट को समझना बहुत महत्वपूर्ण है।

In forward direction, starts at 0 and ends at len-1

In backward direction, starts at -1 and ends at -len

जब आप कहते हैं [a: b: c], आप c (आगे या पीछे) के चिन्ह के आधार पर कह रहे हैं, a पर शुरू करें और b पर समाप्त करें (bth इंडेक्स पर तत्व को छोड़कर)। ऊपर दिए गए अनुक्रमण नियम का उपयोग करें और याद रखें कि आपको इस श्रेणी में केवल तत्व मिलेंगे:

-len, -len+1, -len+2, ..., 0, 1, 2,3,4 , len -1

लेकिन यह सीमा दोनों दिशाओं में असीम रूप से जारी है:

...,-len -2 ,-len-1,-len, -len+1, -len+2, ..., 0, 1, 2,3,4 , len -1, len, len +1, len+2 , ....

उदाहरण के लिए:

             0    1    2   3    4   5   6   7   8   9   10   11
             a    s    t   r    i   n   g
    -9  -8  -7   -6   -5  -4   -3  -2  -1

यदि a, b, और c की आपकी पसंद ऊपर की सीमा के साथ ओवरलैप करने की अनुमति देती है जैसा कि आप a, b, c के लिए नियमों का उपयोग करते हुए ऊपर करते हैं, तो आपको तत्वों के साथ एक सूची मिल जाएगी (traversal के दौरान छुआ हुआ) या आपको एक खाली सूची मिलेगी।

एक अंतिम बात: यदि a और b बराबर हैं, तो आपको एक खाली सूची भी मिलेगी:

>>> l1
[2, 3, 4]

>>> l1[:]
[2, 3, 4]

>>> l1[::-1] # a default is -1 , b default is -(len+1)
[4, 3, 2]

>>> l1[:-4:-1] # a default is -1
[4, 3, 2]

>>> l1[:-3:-1] # a default is -1
[4, 3]

>>> l1[::] # c default is +1, so a default is 0, b default is len
[2, 3, 4]

>>> l1[::-1] # c is -1 , so a default is -1 and b default is -(len+1)
[4, 3, 2]


>>> l1[-100:-200:-1] # Interesting
[]

>>> l1[-1:-200:-1] # Interesting
[4, 3, 2]


>>> l1[-1:-1:1]
[]


>>> l1[-1:5:1] # Interesting
[4]


>>> l1[1:-7:1]
[]

>>> l1[1:-7:-1] # Interesting
[3, 2]

>>> l1[:-2:-2] # a default is -1, stop(b) at -2 , step(c) by 2 in reverse direction
[4]

Comments

एक और एक दिलचस्प उदाहरण: a = [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 ]; a[:-2:-2]जिसके परिणामस्वरूप[9]

— Deviacium

Answer 8

Http://wiki.python.org/moin/MovingToPythonFromOtherLanguages पर यह शानदार तालिका मिली

Python indexes and slices for a six-element list.
Indexes enumerate the elements, slices enumerate the spaces between the elements.

Index from rear:    -6  -5  -4  -3  -2  -1      a=[0,1,2,3,4,5]    a[1:]==[1,2,3,4,5]
Index from front:    0   1   2   3   4   5      len(a)==6          a[:5]==[0,1,2,3,4]
                   +---+---+---+---+---+---+    a[0]==0            a[:-2]==[0,1,2,3]
                   | a | b | c | d | e | f |    a[5]==5            a[1:2]==[1]
                   +---+---+---+---+---+---+    a[-1]==5           a[1:-1]==[1,2,3,4]
Slice from front:  :   1   2   3   4   5   :    a[-2]==4
Slice from rear:   :  -5  -4  -3  -2  -1   :
                                                b=a[:]
                                                b==[0,1,2,3,4,5] (shallow copy of a)

Answer 9

इसका उपयोग करने के बाद मुझे थोड़ा सा एहसास हुआ कि सबसे सरल विवरण यह है कि यह बिल्कुल एक forलूप में तर्कों के समान है ...

(from:to:step)

उनमें से कोई भी वैकल्पिक हैं:

(:to:step)
(from::step)
(from:to)

फिर नकारात्मक इंडेक्सिंग को आपको इसे समझने के लिए नकारात्मक सूचकांकों के लिए स्ट्रिंग की लंबाई जोड़ने की आवश्यकता है।

यह मेरे लिए वैसे भी काम करता है ...

Answer 10

मुझे यह याद रखना आसान है कि यह कैसे काम करता है, और फिर मैं किसी भी विशिष्ट शुरुआत / स्टॉप / स्टेप संयोजन का पता लगा सकता हूं।

यह range()पहले समझने का निर्देश है :

def range(start=0, stop, step=1):  # Illegal syntax, but that's the effect
    i = start
    while (i < stop if step > 0 else i > stop):
        yield i
        i += step

से शुरू करें start, वृद्धि से step, तक नहीं पहुँचें stop। बहुत आसान।

नकारात्मक कदम के बारे में याद रखने वाली बात यह है कि stopहमेशा बाहर रखा गया अंत होता है, चाहे वह उच्च या निम्न हो। यदि आप विपरीत क्रम में एक ही स्लाइस चाहते हैं, तो अलग-अलग करना बहुत साफ है: उदाहरण के लिए 'abcde'[1:-2][::-1]एक चार बायें से स्लाइस, दो से दाएं, फिर से पीछे। (यह भी देखें reversed()।)

अनुक्रम स्लाइसिंग समान है, सिवाय इसके कि यह पहले नकारात्मक सूचकांक को सामान्य करता है, और यह अनुक्रम से बाहर कभी नहीं जा सकता है:

TODO : नीचे दिए गए कोड में एक बग था, जो "अनुक्रम से बाहर कभी नहीं जाता" जब एब्स (स्टेप)> 1; मुझे लगता है कि मैंने इसे सही करने के लिए पैच किया, लेकिन इसे समझना मुश्किल है।

def this_is_how_slicing_works(seq, start=None, stop=None, step=1):
    if start is None:
        start = (0 if step > 0 else len(seq)-1)
    elif start < 0:
        start += len(seq)
    if not 0 <= start < len(seq):  # clip if still outside bounds
        start = (0 if step > 0 else len(seq)-1)
    if stop is None:
        stop = (len(seq) if step > 0 else -1)  # really -1, not last element
    elif stop < 0:
        stop += len(seq)
    for i in range(start, stop, step):
        if 0 <= i < len(seq):
            yield seq[i]

is Noneविवरणों के बारे में चिंता न करें - बस याद रखें कि चूक startऔर / या stopहमेशा आपको सही क्रम देने के लिए सही काम करता है।

नकारात्मक सूचकांक को सामान्य करने से सबसे पहले शुरुआत और / या अंत से स्वतंत्र रूप से गिने जाने की अनुमति मिलती है: 'abcde'[1:-2] == 'abcde'[1:3] == 'bc'बावजूद range(1,-2) == []। सामान्यीकरण को कभी-कभी "मोडुलो द लेंथ" के रूप में माना जाता है, लेकिन ध्यान दें कि यह लंबाई को सिर्फ एक बार जोड़ता है: उदाहरण के 'abcde'[-53:42]लिए बस पूरी स्ट्रिंग है।

Comments

this_is_how_slicing_worksअजगर टुकड़ा के रूप में ही नहीं है। ईजी [0, 1, 2][-5:3:3]को अजगर में [0] list(this_is_how_slicing_works([0, 1, 2], -5, 3, 3))मिलेगा , लेकिन [1] मिलेगा।

— Eastsun

@ इयूनसन ओह, तुम सही हो! एक स्पष्ट मामला: range(4)[-200:200:3] == [0, 3]लेकिन list(this_is_how_slicing_works([0, 1, 2, 3], -200, 200, 3)) == [2]। मेरी if 0 <= i < len(seq):कोशिश थी कि "कभी भी अनुक्रम से बाहर न जाऊं" बस कदम 1 के लिए गलत है। मैं इसे बाद में आज (परीक्षण के साथ) फिर से लिखूंगा।

— बेनी चेर्नियाव्स्की-पास्किन

Answer 11

मैं इसके बारे में सोचने के तरीके के बीच "तत्वों के बीच एक सूचकांक अंक" का उपयोग करता हूं, लेकिन इसका वर्णन करने का एक तरीका जो कभी-कभी दूसरों को प्राप्त करने में मदद करता है:

mylist[X:Y]

X आपके इच्छित पहले तत्व का सूचकांक है।
Y वह पहला तत्व है जिसे आप नहीं चाहते हैं।

Answer 12

Index:
      ------------>
  0   1   2   3   4
+---+---+---+---+---+
| a | b | c | d | e |
+---+---+---+---+---+
  0  -4  -3  -2  -1
      <------------

Slice:
    <---------------|
|--------------->
:   1   2   3   4   :
+---+---+---+---+---+
| a | b | c | d | e |
+---+---+---+---+---+
:  -4  -3  -2  -1   :
|--------------->
    <---------------|

मुझे उम्मीद है कि यह आपको पायथन में सूची बनाने में मदद करेगा।

संदर्भ: http://wiki.python.org/moin/MovingToPythonFromOtherLanguages

Answer 13

पायथन स्लाइस अंकन:

a[start:end:step]

• के लिए startऔरend , ऋणात्मक मानों अनुक्रम के अंत के सापेक्ष किया जा रहा है के रूप में व्याख्या कर रहे हैं।
• के बादend स्थिति को इंगित करने के लिए सकारात्मक संकेतअंतिम तत्वों को शामिल करने के ।
• खाली मान निम्नानुसार चूक रहे हैं: [+0:-0:1]।
• एक नकारात्मक कदम का उपयोग करने की व्याख्या उलट जाती है startऔरend

अंकन (संख्या) मैट्रिसेस और बहुआयामी सरणियों तक फैला हुआ है। उदाहरण के लिए, आपके द्वारा उपयोग किए जा सकने वाले संपूर्ण स्तंभों को टुकड़ा करने के लिए:

m[::,0:2:] ## slice the first two columns

स्लाइस संदर्भों को रखती है, कॉपी नहीं, सरणी तत्वों की। यदि आप एक अलग प्रतिलिपि एक सरणी बनाना चाहते हैं, तो आप उपयोग कर सकते हैं deepcopy()।

Answer 14

आप किसी सूची से एक या अधिक तत्वों को निकालने के लिए स्लाइस असाइनमेंट का उपयोग कर सकते हैं:

r = [1, 'blah', 9, 8, 2, 3, 4]
>>> r[1:4] = []
>>> r
[1, 2, 3, 4]

Answer 15

यह सिर्फ कुछ अतिरिक्त जानकारी के लिए है ... नीचे दी गई सूची पर विचार करें

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

>>> l[::-1]
[467, 945, 7, 67, 456, 345, 23, 12]

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

Answer 16

यह है कि मैं कैसे newbies को स्लाइस सिखाता हूं:

अनुक्रमण और स्लाइसिंग के बीच अंतर को समझना:

विकी पायथन की यह अद्भुत तस्वीर है जो स्पष्ट रूप से अनुक्रमण और स्लाइसिंग को अलग करती है।

यह छह तत्वों के साथ एक सूची है। स्लाइसिंग को बेहतर ढंग से समझने के लिए, उस सूची को एक साथ रखे गए छह बक्सों के समूह के रूप में समझें। प्रत्येक बॉक्स में एक वर्णमाला है।

अनुक्रमण बॉक्स की सामग्री से निपटने जैसा है। आप किसी भी बॉक्स की सामग्री की जाँच कर सकते हैं। लेकिन आप एक साथ कई बॉक्स की सामग्री की जाँच नहीं कर सकते। आप बॉक्स की सामग्री को भी बदल सकते हैं। लेकिन आप दो गेंदों को एक बॉक्स में नहीं रख सकते हैं या एक बार में दो गेंदों को बदल सकते हैं।

In [122]: alpha = ['a', 'b', 'c', 'd', 'e', 'f']

In [123]: alpha
Out[123]: ['a', 'b', 'c', 'd', 'e', 'f']

In [124]: alpha[0]
Out[124]: 'a'

In [127]: alpha[0] = 'A'

In [128]: alpha
Out[128]: ['A', 'b', 'c', 'd', 'e', 'f']

In [129]: alpha[0,1]
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-129-c7eb16585371> in <module>()
----> 1 alpha[0,1]

TypeError: list indices must be integers, not tuple

स्लाइसिंग खुद बक्से से निपटने जैसा है। आप पहले बॉक्स को उठाकर दूसरी टेबल पर रख सकते हैं। बॉक्स को लेने के लिए, आपको सभी को पता होना चाहिए कि बॉक्स की शुरुआत और समाप्ति की स्थिति क्या है।

तुम भी पहले तीन बक्से या पिछले दो बक्से या 1 और 4 के बीच सभी बक्से उठा सकते हैं। तो, आप बक्से के किसी भी सेट को चुन सकते हैं यदि आप शुरुआत और अंत जानते हैं। इन स्थितियों को स्टार्ट और स्टॉप पोजीशन कहा जाता है।

दिलचस्प बात यह है कि आप एक साथ कई बॉक्स बदल सकते हैं। इसके अलावा आप जहाँ चाहें वहाँ कई बक्से रख सकते हैं।

In [130]: alpha[0:1]
Out[130]: ['A']

In [131]: alpha[0:1] = 'a'

In [132]: alpha
Out[132]: ['a', 'b', 'c', 'd', 'e', 'f']

In [133]: alpha[0:2] = ['A', 'B']

In [134]: alpha
Out[134]: ['A', 'B', 'c', 'd', 'e', 'f']

In [135]: alpha[2:2] = ['x', 'xx']

In [136]: alpha
Out[136]: ['A', 'B', 'x', 'xx', 'c', 'd', 'e', 'f']

चरण के साथ टुकड़ा करना:

अब तक आपने लगातार बॉक्स उठाए हैं। लेकिन कभी-कभी आपको विवेक से काम लेने की जरूरत होती है। उदाहरण के लिए, आप हर दूसरे बॉक्स को उठा सकते हैं। तुम भी अंत से हर तीसरे बॉक्स उठा सकते हैं। इस मान को स्टेप साइज कहा जाता है। यह आपके क्रमिक पिकअप के बीच की खाई को दर्शाता है। यदि आप शुरुआत से अंत तक बॉक्स उठा रहे हैं और इसके विपरीत, तो चरण का आकार सकारात्मक होना चाहिए।

In [137]: alpha = ['a', 'b', 'c', 'd', 'e', 'f']

In [142]: alpha[1:5:2]
Out[142]: ['b', 'd']

In [143]: alpha[-1:-5:-2]
Out[143]: ['f', 'd']

In [144]: alpha[1:5:-2]
Out[144]: []

In [145]: alpha[-1:-5:2]
Out[145]: []

कैसे पायथन आंकड़े लापता पैरामीटर से बाहर निकलते हैं:

स्लाइस करते समय, यदि आप किसी भी पैरामीटर को छोड़ देते हैं, तो पायथन अपने आप यह पता लगाने की कोशिश करता है।

यदि आप CPython के स्रोत कोड की जांच करते हैं , तो आपको PySlice_GetIndicesEx () नामक एक फ़ंक्शन मिलेगा जो किसी भी दिए गए मापदंडों के लिए सूचकांकों को इंगित करता है। यहाँ पाइथन में तार्किक समकक्ष कोड है।

यह फ़ंक्शन स्लाइसिंग के लिए पायथन ऑब्जेक्ट और वैकल्पिक पैरामीटर लेता है और अनुरोधित स्लाइस के लिए स्टार्ट, स्टॉप, स्टेप और स्लाइस की लंबाई लौटाता है।

def py_slice_get_indices_ex(obj, start=None, stop=None, step=None):

    length = len(obj)

    if step is None:
        step = 1
    if step == 0:
        raise Exception("Step cannot be zero.")

    if start is None:
        start = 0 if step > 0 else length - 1
    else:
        if start < 0:
            start += length
        if start < 0:
            start = 0 if step > 0 else -1
        if start >= length:
            start = length if step > 0 else length - 1

    if stop is None:
        stop = length if step > 0 else -1
    else:
        if stop < 0:
            stop += length
        if stop < 0:
            stop = 0 if step > 0 else -1
        if stop >= length:
            stop = length if step > 0 else length - 1

    if (step < 0 and stop >= start) or (step > 0 and start >= stop):
        slice_length = 0
    elif step < 0:
        slice_length = (stop - start + 1)/(step) + 1
    else:
        slice_length = (stop - start - 1)/(step) + 1

    return (start, stop, step, slice_length)

यह वह बुद्धिमत्ता है जो स्लाइस के पीछे मौजूद है। चूंकि पायथन में एक अंतर्निहित फ़ंक्शन होता है जिसे स्लाइस कहा जाता है, आप कुछ मापदंडों को पास कर सकते हैं और जांच सकते हैं कि यह कैसे लापता मापदंडों की गणना करता है।

In [21]: alpha = ['a', 'b', 'c', 'd', 'e', 'f']

In [22]: s = slice(None, None, None)

In [23]: s
Out[23]: slice(None, None, None)

In [24]: s.indices(len(alpha))
Out[24]: (0, 6, 1)

In [25]: range(*s.indices(len(alpha)))
Out[25]: [0, 1, 2, 3, 4, 5]

In [26]: s = slice(None, None, -1)

In [27]: range(*s.indices(len(alpha)))
Out[27]: [5, 4, 3, 2, 1, 0]

In [28]: s = slice(None, 3, -1)

In [29]: range(*s.indices(len(alpha)))
Out[29]: [5, 4]

नोट: यह पोस्ट मूल रूप से मेरे ब्लॉग, द इंटेलिजेंस बिहाइंड पायथन स्लाइस में लिखी गई थी ।

Answer 17

एक सामान्य नियम के रूप में, बहुत सारे हार्डकोड इंडेक्स वैल्यू वाले कोड लिखने से पठनीयता और रखरखाव गड़बड़ हो जाता है। उदाहरण के लिए, यदि आप एक साल बाद कोड पर वापस आते हैं, तो आप इसे देखेंगे और आश्चर्य करेंगे कि जब आप इसे लिख रहे थे तो आप क्या सोच रहे थे। दिखाया गया समाधान केवल अधिक स्पष्ट रूप से यह बताने का एक तरीका है कि आपका कोड वास्तव में क्या कर रहा है। सामान्य तौर पर, अंतर्निहित स्लाइस () एक स्लाइस ऑब्जेक्ट बनाता है जिसका उपयोग कहीं भी किया जा सकता है एक स्लाइस की अनुमति है। उदाहरण के लिए:

>>> items = [0, 1, 2, 3, 4, 5, 6]
>>> a = slice(2, 4)
>>> items[2:4]
[2, 3]
>>> items[a]
[2, 3]
>>> items[a] = [10,11]
>>> items
[0, 1, 10, 11, 4, 5, 6]
>>> del items[a]
>>> items
[0, 1, 4, 5, 6]

यदि आपके पास एक स्लाइस उदाहरण है, तो आप क्रमशः इसके s.start, s.stop और s.step विशेषताओं को देखकर इसके बारे में अधिक जानकारी प्राप्त कर सकते हैं। उदाहरण के लिए:

>>> a = slice(10, 50, 2)
>>> a.start
10
>>> a.stop
50
>>> a.step
2
>>>

Answer 18

1. स्लाइस नोटेशन

इसे सरल बनाने के लिए, याद रखें कि स्लाइस का केवल एक रूप है remember

s[start:end:step]

और यहाँ है कि यह कैसे काम करता है:

• s: एक वस्तु जिसे कटा जा सकता है
• start: चलना शुरू करने के लिए पहला सूचकांक
• end: अंतिम इंडेक्स, ध्यान दें कि endइंडेक्स परिणामी स्लाइस में शामिल नहीं होगा
• step: प्रत्येक stepसूचकांक तत्व उठाओ

एक और आयात बात: सब start, end, stepछोड़ा जा सकता है! और अगर वे छोड़े गए हैं, उनके डिफ़ॉल्ट मान का उपयोग किया जाएगा: 0, len(s),1 तदनुसार।

तो संभव विविधताएं हैं:

# Mostly used variations
s[start:end]
s[start:]
s[:end]

# Step-related variations
s[:end:step]
s[start::step]
s[::step]

# Make a copy
s[:]

नोट: यदि start >= end(केवल विचार करते समय step>0), पायथन एक खाली टुकड़ा लौटाएगा[] ।

2. नुकसान

उपरोक्त भाग कोर सुविधाओं को बताता है कि स्लाइस कैसे काम करती है, और यह ज्यादातर अवसरों पर काम करेगी। हालाँकि, ऐसे नुकसान हो सकते हैं जिन्हें आपको देखना चाहिए, और यह हिस्सा उन्हें समझाता है।

नकारात्मक सूचकांक

पायथन सीखने वालों को भ्रमित करने वाली पहली बात यह है कि एक सूचकांक नकारात्मक हो सकता है! घबराओ मत: एक नकारात्मक सूचकांक का अर्थ है पीछे की ओर गिनना।

उदाहरण के लिए:

s[-5:]    # Start at the 5th index from the end of array,
          # thus returning the last 5 elements.
s[:-5]    # Start at index 0, and end until the 5th index from end of array,
          # thus returning s[0:len(s)-5].

नकारात्मक कदम

चीजों को और अधिक भ्रमित करना stepनकारात्मक भी हो सकता है!

एक नकारात्मक कदम का अर्थ है सरणी को पीछे की ओर से जोड़ना: अंत से शुरू करने के लिए, अंत में शामिल इंडेक्स और परिणाम से बाहर रखा गया इंडेक्स।

नोट : जब चरण नकारात्मक है, तो डिफ़ॉल्ट मान startहै len(s)(जबकि endइसमें समतुल्य नहीं है 0, क्योंकि s[::-1]इसमें शामिल है s[0])। उदाहरण के लिए:

s[::-1]            # Reversed slice
s[len(s)::-1]      # The same as above, reversed slice
s[0:len(s):-1]     # Empty list

सीमा त्रुटि से बाहर?

आश्चर्यचकित रहिए: जब सूचकांक सीमा से बाहर हो तो स्लाइस एक इंडेक्सइर को नहीं बढ़ाता है!

यदि सूचकांक सीमा से बाहर है, तो पायथन इंडेक्स को स्थिति के अनुसार 0या उसके len(s)अनुसार सेट करने की पूरी कोशिश करेगा । उदाहरण के लिए:

s[:len(s)+5]      # The same as s[:len(s)]
s[-len(s)-5::]    # The same as s[0:]
s[len(s)+5::-1]   # The same as s[len(s)::-1], and the same as s[::-1]

3. उदाहरण

आइए इस उत्तर को उदाहरणों के साथ समाप्त करते हैं, हमने जो भी चर्चा की है, उसके बारे में बताते हुए:

# Create our array for demonstration
In [1]: s = [i for i in range(10)]

In [2]: s
Out[2]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

In [3]: s[2:]   # From index 2 to last index
Out[3]: [2, 3, 4, 5, 6, 7, 8, 9]

In [4]: s[:8]   # From index 0 up to index 8
Out[4]: [0, 1, 2, 3, 4, 5, 6, 7]

In [5]: s[4:7]  # From index 4 (included) up to index 7(excluded)
Out[5]: [4, 5, 6]

In [6]: s[:-2]  # Up to second last index (negative index)
Out[6]: [0, 1, 2, 3, 4, 5, 6, 7]

In [7]: s[-2:]  # From second last index (negative index)
Out[7]: [8, 9]

In [8]: s[::-1] # From last to first in reverse order (negative step)
Out[8]: [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

In [9]: s[::-2] # All odd numbers in reversed order
Out[9]: [9, 7, 5, 3, 1]

In [11]: s[-2::-2] # All even numbers in reversed order
Out[11]: [8, 6, 4, 2, 0]

In [12]: s[3:15]   # End is out of range, and Python will set it to len(s).
Out[12]: [3, 4, 5, 6, 7, 8, 9]

In [14]: s[5:1]    # Start > end; return empty list
Out[14]: []

In [15]: s[11]     # Access index 11 (greater than len(s)) will raise an IndexError
---------------------------------------------------------------------------
IndexError                                Traceback (most recent call last)
<ipython-input-15-79ffc22473a3> in <module>()
----> 1 s[11]

IndexError: list index out of range

Answer 19

पिछले उत्तरों में बहु-आयामी सरणी स्लाइसिंग पर चर्चा नहीं की गई है जो कि प्रसिद्ध न्यूपे पैकेज का उपयोग करना संभव है :

स्लाइसिंग को बहुआयामी सरणियों पर भी लागू किया जा सकता है।

# Here, a is a NumPy array

>>> a
array([[ 1,  2,  3,  4],
       [ 5,  6,  7,  8],
       [ 9, 10, 11, 12]])
>>> a[:2, 0:3:2]
array([[1, 3],
       [5, 7]])

" :2" इससे पहले कि अल्पविराम पहले आयाम पर चल रही है और " 0:3:2" के बाद अल्पविराम दूसरे आयाम में चल रही है।

Comments

बस एक दोस्ताना याद दिलाता हूं कि आप इसे अजगर पर नहीं कर सकते हैं listलेकिन केवल arrayनम्पी में

— मंगल ली

Answer 20

#!/usr/bin/env python

def slicegraphical(s, lista):

    if len(s) > 9:
        print """Enter a string of maximum 9 characters,
    so the printig would looki nice"""
        return 0;
    # print " ",
    print '  '+'+---' * len(s) +'+'
    print ' ',
    for letter in s:
        print '| {}'.format(letter),
    print '|'
    print " ",; print '+---' * len(s) +'+'

    print " ",
    for letter in range(len(s) +1):
        print '{}  '.format(letter),
    print ""
    for letter in range(-1*(len(s)), 0):
        print ' {}'.format(letter),
    print ''
    print ''


    for triada in lista:
        if len(triada) == 3:
            if triada[0]==None and triada[1] == None and triada[2] == None:
                # 000
                print s+'[   :   :   ]' +' = ', s[triada[0]:triada[1]:triada[2]]
            elif triada[0] == None and triada[1] == None and triada[2] != None:
                # 001
                print s+'[   :   :{0:2d} ]'.format(triada[2], '','') +' = ', s[triada[0]:triada[1]:triada[2]]
            elif triada[0] == None and triada[1] != None and triada[2] == None:
                # 010
                print s+'[   :{0:2d} :   ]'.format(triada[1]) +' = ', s[triada[0]:triada[1]:triada[2]]
            elif triada[0] == None and triada[1] != None and triada[2] != None:
                # 011
                print s+'[   :{0:2d} :{1:2d} ]'.format(triada[1], triada[2]) +' = ', s[triada[0]:triada[1]:triada[2]]
            elif triada[0] != None and triada[1] == None and triada[2] == None:
                # 100
                print s+'[{0:2d} :   :   ]'.format(triada[0]) +' = ', s[triada[0]:triada[1]:triada[2]]
            elif triada[0] != None and triada[1] == None and triada[2] != None:
                # 101
                print s+'[{0:2d} :   :{1:2d} ]'.format(triada[0], triada[2]) +' = ', s[triada[0]:triada[1]:triada[2]]
            elif triada[0] != None and triada[1] != None and triada[2] == None:
                # 110
                print s+'[{0:2d} :{1:2d} :   ]'.format(triada[0], triada[1]) +' = ', s[triada[0]:triada[1]:triada[2]]
            elif triada[0] != None and triada[1] != None and triada[2] != None:
                # 111
                print s+'[{0:2d} :{1:2d} :{2:2d} ]'.format(triada[0], triada[1], triada[2]) +' = ', s[triada[0]:triada[1]:triada[2]]

        elif len(triada) == 2:
            if triada[0] == None and triada[1] == None:
                # 00
                print s+'[   :   ]    ' + ' = ', s[triada[0]:triada[1]]
            elif triada[0] == None and triada[1] != None:
                # 01
                print s+'[   :{0:2d} ]    '.format(triada[1]) + ' = ', s[triada[0]:triada[1]]
            elif triada[0] != None and triada[1] == None:
                # 10
                print s+'[{0:2d} :   ]    '.format(triada[0]) + ' = ', s[triada[0]:triada[1]]
            elif triada[0] != None and triada[1] != None:
                # 11
                print s+'[{0:2d} :{1:2d} ]    '.format(triada[0],triada[1]) + ' = ', s[triada[0]:triada[1]]

        elif len(triada) == 1:
            print s+'[{0:2d} ]        '.format(triada[0]) + ' = ', s[triada[0]]


if __name__ == '__main__':
    # Change "s" to what ever string you like, make it 9 characters for
    # better representation.
    s = 'COMPUTERS'

    # add to this list different lists to experement with indexes
    # to represent ex. s[::], use s[None, None,None], otherwise you get an error
    # for s[2:] use s[2:None]

    lista = [[4,7],[2,5,2],[-5,1,-1],[4],[-4,-6,-1], [2,-3,1],[2,-3,-1], [None,None,-1],[-5,None],[-5,0,-1],[-5,None,-1],[-1,1,-2]]

    slicegraphical(s, lista)

आप इस स्क्रिप्ट को चला सकते हैं और इसके साथ प्रयोग कर सकते हैं, नीचे कुछ नमूने हैं जो मुझे स्क्रिप्ट से मिले हैं।

  +---+---+---+---+---+---+---+---+---+
  | C | O | M | P | U | T | E | R | S |
  +---+---+---+---+---+---+---+---+---+
  0   1   2   3   4   5   6   7   8   9   
 -9  -8  -7  -6  -5  -4  -3  -2  -1 

COMPUTERS[ 4 : 7 ]     =  UTE
COMPUTERS[ 2 : 5 : 2 ] =  MU
COMPUTERS[-5 : 1 :-1 ] =  UPM
COMPUTERS[ 4 ]         =  U
COMPUTERS[-4 :-6 :-1 ] =  TU
COMPUTERS[ 2 :-3 : 1 ] =  MPUT
COMPUTERS[ 2 :-3 :-1 ] =  
COMPUTERS[   :   :-1 ] =  SRETUPMOC
COMPUTERS[-5 :   ]     =  UTERS
COMPUTERS[-5 : 0 :-1 ] =  UPMO
COMPUTERS[-5 :   :-1 ] =  UPMOC
COMPUTERS[-1 : 1 :-2 ] =  SEUM
[Finished in 0.9s]

एक नकारात्मक कदम का उपयोग करते समय, ध्यान दें कि उत्तर 1 से दाईं ओर स्थानांतरित हो गया है।

Answer 21

मेरे दिमाग को यह स्वीकार करने में खुशी होती है कि lst[start:end]इसमें start-थ आइटम है। मैं यह भी कह सकता हूं कि यह एक 'प्राकृतिक धारणा' है।

लेकिन कभी-कभार इसमें संदेह पैदा हो जाता है और मेरा दिमाग फिर से आश्वस्त हो जाता है कि इसमें कोई endतत्व नहीं है।

इन क्षणों में मैं इस सरल प्रमेय पर भरोसा करता हूं:

for any n,    lst = lst[:n] + lst[n:]

यह सुंदर संपत्ति मुझे बताती है कि lst[start:end]इसमें end-th आइटम नहीं है क्योंकि यह अंदर है lst[end:]।

ध्यान दें कि यह प्रमेय किसी भी लिए सही है n। उदाहरण के लिए, आप यह देख सकते हैं

lst = range(10)
lst[:-42] + lst[-42:] == lst

लौटता है True।

Answer 22

मेरी राय में, आप पायथन स्ट्रिंग स्लाइसन संकेतन को बेहतर ढंग से समझेंगे और याद रखेंगे यदि आप इसे निम्न तरीके से पढ़ते हैं (पढ़ें)।

निम्नलिखित स्ट्रिंग के साथ काम करते हैं ...

azString = "abcdefghijklmnopqrstuvwxyz"

जो नहीं जानते हैं, उनके लिए आप azStringनोटेशन का उपयोग करने से कोई भी विकल्प बना सकते हैंazString[x:y]

अन्य प्रोग्रामिंग भाषाओं से आ रहा है, कि जब सामान्य ज्ञान समझौता हो जाता है। X और y क्या हैं?

मुझे याद रखने की तकनीक के लिए अपनी खोज में कई परिदृश्यों को बैठना और चलाना था, जो मुझे याद रखने में मदद करेंगे कि क्या x और y हैं और पहले प्रयास में मुझे स्लाइस स्ट्रिंग्स को ठीक से करने में मदद करेंगे।

मेरा निष्कर्ष यह है कि एक्स और वाई को सीमा सूचकांक के रूप में देखा जाना चाहिए जो उन स्ट्रिंग्स के आसपास हैं जिन्हें हम अतिरिक्त करना चाहते हैं। इसलिए हमें अभिव्यक्ति को azString[index1, index2]और भी स्पष्ट रूप में देखना चाहिएazString[index_of_first_character, index_after_the_last_character] ।

यहाँ एक उदाहरण है कि ...

Letters   a b c d e f g h i j ...
         ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑
             ┊           ┊
Indexes  0 1 2 3 4 5 6 7 8 9 ...
             ┊           ┊
cdefgh    index1       index2

तो आपको बस इतना करना है कि index1 और index2 को उन मानों पर सेट करना है जो वांछित विकल्प को घेर लेंगे। उदाहरण के लिए, प्रतिस्थापन "सेडेफ" प्राप्त करने के लिए, आप उपयोग कर सकते हैंazString[2:8] , क्योंकि "c" के बाईं ओर का सूचकांक 2 है और "h" के दाहिने आकार का 8 है।

याद रखें कि हम सीमाएँ निर्धारित कर रहे हैं। और वे सीमाएँ ऐसी स्थितियाँ हैं जहाँ आप कुछ कोष्ठक रख सकते हैं जो इस प्रकार प्रतिस्थापित हो सकते हैं ...

ab [ cdefgh ] ij

वह चाल हर समय काम करती है और याद रखना आसान है।

Answer 23

पिछले उत्तरों में से अधिकांश स्लाइस अंकन के बारे में सवाल उठाते हैं।

स्लाइसिंग के लिए उपयोग किए गए विस्तारित अनुक्रमण सिंटैक्स है aList[start:stop:step], और मूल उदाहरण हैं:

:

अधिक स्लाइसिंग उदाहरण: 15 विस्तारित स्लाइस

Answer 24

पायथन में, कटाई के लिए सबसे बुनियादी रूप निम्न है:

l[start:end]

जहां lकुछ संग्रह है, startएक समावेशी सूचकांक है, और endएक विशेष सूचकांक है।

In [1]: l = list(range(10))

In [2]: l[:5] # First five elements
Out[2]: [0, 1, 2, 3, 4]

In [3]: l[-5:] # Last five elements
Out[3]: [5, 6, 7, 8, 9]

शुरुआत से स्लाइस करते समय, आप शून्य इंडेक्स को छोड़ सकते हैं, और अंत में स्लाइस करते समय, आप अंतिम इंडेक्स को छोड़ सकते हैं क्योंकि यह बेमानी है, इसलिए क्रिया न करें:

In [5]: l[:3] == l[0:3]
Out[5]: True

In [6]: l[7:] == l[7:len(l)]
Out[6]: True

ऋणात्मक पूर्णांक किसी संग्रह के अंत के सापेक्ष ऑफसेट करते समय उपयोगी होते हैं:

In [7]: l[:-1] # Include all elements but the last one
Out[7]: [0, 1, 2, 3, 4, 5, 6, 7, 8]

In [8]: l[-3:] # Take the last three elements
Out[8]: [7, 8, 9]

यह संभव है कि ऐसे संकेत मिलें जो सीमा से बाहर हों, जैसे कि टुकड़ा करते समय:

In [9]: l[:20] # 20 is out of index bounds, and l[20] will raise an IndexError exception
Out[9]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

In [11]: l[-20:] # -20 is out of index bounds, and l[-20] will raise an IndexError exception
Out[11]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

ध्यान रखें कि एक संग्रह को टुकड़ा करने का परिणाम एक नया संग्रह है। इसके अलावा, असाइनमेंट में स्लाइस नोटेशन का उपयोग करते समय, स्लाइस असाइनमेंट की लंबाई समान होने की आवश्यकता नहीं है। असाइन किए गए स्लाइस से पहले और बाद के मूल्यों को रखा जाएगा, और नए मूल्यों को समाहित करने के लिए संग्रह सिकुड़ जाएगा या बढ़ जाएगा:

In [16]: l[2:6] = list('abc') # Assigning fewer elements than the ones contained in the sliced collection l[2:6]

In [17]: l
Out[17]: [0, 1, 'a', 'b', 'c', 6, 7, 8, 9]

In [18]: l[2:5] = list('hello') # Assigning more elements than the ones contained in the sliced collection l [2:5]

In [19]: l
Out[19]: [0, 1, 'h', 'e', 'l', 'l', 'o', 6, 7, 8, 9]

यदि आप प्रारंभ और अंत इंडेक्स को छोड़ देते हैं, तो आप संग्रह की एक प्रति बनाएंगे:

In [14]: l_copy = l[:]

In [15]: l == l_copy and l is not l_copy
Out[15]: True

यदि असाइनमेंट ऑपरेशन करते समय स्टार्ट और एंड इंडेक्स को छोड़ दिया जाता है, तो संग्रह की पूरी सामग्री को संदर्भित की गई कॉपी के साथ बदल दिया जाएगा:

In [20]: l[:] = list('hello...')

In [21]: l
Out[21]: ['h', 'e', 'l', 'l', 'o', '.', '.', '.']

बुनियादी स्लाइसिंग के अलावा, निम्नलिखित संकेतन को लागू करना भी संभव है:

l[start:end:step]

जहां lएक संग्रह है, startएक समावेशी सूचकांक है, endएक विशेष सूचकांक है, और stepएक ऐसा स्ट्राइड है जिसका उपयोग प्रत्येक एनटी आइटम को करने के लिए किया जा सकता है l।

In [22]: l = list(range(10))

In [23]: l[::2] # Take the elements which indexes are even
Out[23]: [0, 2, 4, 6, 8]

In [24]: l[1::2] # Take the elements which indexes are odd
Out[24]: [1, 3, 5, 7, 9]

stepपाइथन में संग्रह को उलटने के लिए एक उपयोगी ट्रिक का उपयोग करना :

In [25]: l[::-1]
Out[25]: [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

stepनिम्न उदाहरण के लिए नकारात्मक पूर्णांक का उपयोग करना भी संभव है :

In[28]:  l[::-2]
Out[28]: [9, 7, 5, 3, 1]

हालांकि, के लिए एक नकारात्मक मूल्य का उपयोग करना stepबहुत भ्रामक हो सकता है। इसके अलावा, आदेश होने के लिए pythonic , आप का उपयोग कर से बचना चाहिए start, endऔर stepएक भी टुकड़ा में। यदि यह आवश्यक है, तो इसे दो असाइनमेंट (एक टुकड़ा करने के लिए, और दूसरा स्ट्राइड) में करने पर विचार करें।

In [29]: l = l[::2] # This step is for striding

In [30]: l
Out[30]: [0, 2, 4, 6, 8]

In [31]: l = l[1:-1] # This step is for slicing

In [32]: l
Out[32]: [2, 4, 6]

Answer 25

मैं एक हैलो, विश्व जोड़ना चाहता हूं ! उदाहरण जो बहुत शुरुआती लोगों के लिए स्लाइस की मूल बातें बताते हैं। इसने मेरी बहुत मदद की।

चलो छह मूल्यों के साथ एक सूची है ['P', 'Y', 'T', 'H', 'O', 'N']:

+---+---+---+---+---+---+
| P | Y | T | H | O | N |
+---+---+---+---+---+---+
  0   1   2   3   4   5

अब उस सूची के सबसे सरल स्लाइस उसके उपविजेता हैं। संकेतन है [<index>:<index>]और कुंजी इसे इस तरह पढ़ना है:

[ start cutting before this index : end cutting before this index ]

अब यदि आप [2:5]ऊपर दी गई सूची का एक टुकड़ा बनाते हैं , तो यह होगा:

        |           |
+---+---|---+---+---|---+
| P | Y | T | H | O | N |
+---+---|---+---+---|---+
  0   1 | 2   3   4 | 5

आपने इंडेक्स वाले एलिमेंट से पहले एक कट बनाया 2और इंडेक्स वाले एलिमेंट से पहले एक और कट लगाया 5। तो परिणाम उन दो कटौती, एक सूची के बीच एक टुकड़ा होगा ['T', 'H', 'O']।

Answer 26

मैं व्यक्तिगत रूप से एक forपाश की तरह इसके बारे में सोचता हूं :

a[start:end:step]
# for(i = start; i < end; i += step)

इसके अलावा, ध्यान दें कि इसके लिए नकारात्मक मान startऔर endसूची के अंत के सापेक्ष हैं और ऊपर दिए गए उदाहरण में गणना की गई है given_index + a.shape[0]।

Answer 27

नीचे एक स्ट्रिंग के सूचकांक का उदाहरण दिया गया है:

 +---+---+---+---+---+
 | H | e | l | p | A |
 +---+---+---+---+---+
 0   1   2   3   4   5
-5  -4  -3  -2  -1

str="Name string"

कटा हुआ उदाहरण: [प्रारंभ: अंत: चरण]

str[start:end] # Items start through end-1
str[start:]    # Items start through the rest of the array
str[:end]      # Items from the beginning through end-1
str[:]         # A copy of the whole array

नीचे उदाहरण उपयोग है:

print str[0] = N
print str[0:2] = Na
print str[0:7] = Name st
print str[0:7:2] = Nm t
print str[0:-1:2] = Nm ti

Answer 28

यदि आपको लगता है कि स्लाइसिंग में नकारात्मक सूचकांक भ्रामक हैं, तो इसके बारे में सोचने का एक बहुत आसान तरीका है: बस नकारात्मक सूचकांक को इसके साथ बदलें len - index। तो उदाहरण के लिए, -3 को साथ में बदलें len(list) - 3।

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

def slice(list, start = None, end = None, step = 1):
  # Take care of missing start/end parameters
  start = 0 if start is None else start
  end = len(list) if end is None else end

  # Take care of negative start/end parameters
  start = len(list) + start if start < 0 else start
  end = len(list) + end if end < 0 else end

  # Now just execute a for-loop with start, end and step
  return [list[i] for i in range(start, end, step)]

Answer 29

मूल स्लाइसिंग तकनीक प्रारंभिक बिंदु, स्टॉपिंग पॉइंट और स्टेप साइज़ को परिभाषित करने के लिए है - जिसे स्ट्राइड के रूप में भी जाना जाता है।

सबसे पहले, हम अपने स्लाइसिंग में उपयोग करने के लिए मूल्यों की एक सूची बनाएंगे।

टुकड़ा करने के लिए दो सूचियाँ बनाएँ। पहली 1 से 9 तक की संख्यात्मक सूची है (सूची ए)। दूसरी भी एक संख्यात्मक सूची है, 0 से 9 तक (सूची बी):

A = list(range(1, 10, 1)) # Start, stop, and step
B = list(range(9))

print("This is List A:", A)
print("This is List B:", B)

ए से नंबर 3 और बी से नंबर 6 को इंडेक्स करें।

print(A[2])
print(B[6])

बेसिक स्लाइसिंग

स्लाइसिंग के लिए उपयोग किया जाने वाला विस्तारित इंडेक्सिंग सिंटैक्स एलीस्ट [प्रारंभ: स्टॉप: स्टेप] है। प्रारंभ तर्क और चरण तर्क, दोनों में से कोई भी डिफ़ॉल्ट नहीं है - केवल आवश्यक तर्क बंद है। क्या आपने देखा कि यह सूची ए और बी को परिभाषित करने के लिए किस सीमा तक उपयोग किया जाता है? ऐसा इसलिए है क्योंकि स्लाइस ऑब्जेक्ट रेंज (प्रारंभ, स्टॉप, स्टेप) द्वारा निर्दिष्ट सूचकांकों के सेट का प्रतिनिधित्व करता है। अजगर 3.4 दस्तावेज।

जैसा कि आप देख सकते हैं, केवल एक स्टॉप रिटर्न को परिभाषित करना एक तत्व है। चूंकि प्रारंभ में कोई भी चूक नहीं करता है, यह केवल एक तत्व को पुनः प्राप्त करने में अनुवाद करता है।

यह नोट करना महत्वपूर्ण है, पहला तत्व इंडेक्स 0 है, नहीं इंडेक्स 1 । यही कारण है कि हम इस अभ्यास के लिए 2 सूचियों का उपयोग कर रहे हैं। सूची ए के तत्वों को क्रमिक स्थिति के अनुसार गिना जाता है (पहला तत्व 1 है, दूसरा तत्व 2 है, आदि) जबकि सूची बी के तत्व वे संख्याएं हैं जिनका उपयोग उन्हें पहले सूचकांक के लिए किया जाएगा ([0), पहले तत्व 0 के लिए, आदि।)।

विस्तारित अनुक्रमण सिंटैक्स के साथ, हम कई मानों को पुनः प्राप्त करते हैं। उदाहरण के लिए, सभी मूल्यों को एक बृहदान्त्र के साथ पुनर्प्राप्त किया जाता है।

A[:]

तत्वों के एक सबसेट को पुनः प्राप्त करने के लिए, स्टार्ट और स्टॉप पदों को परिभाषित करने की आवश्यकता है।

पैटर्न को देखते हुए aList [start: stop], सूची A से पहले दो तत्वों को पुनः प्राप्त करें।

Answer 30

मुझे नहीं लगता कि पायथन ट्यूटोरियल आरेख (विभिन्न अन्य उत्तरों में उद्धृत) अच्छा है क्योंकि यह सुझाव सकारात्मक प्रगति के लिए काम करता है, लेकिन नकारात्मक प्रगति के लिए नहीं है।

यह आरेख है:

 +---+---+---+---+---+---+
 | P | y | t | h | o | n |
 +---+---+---+---+---+---+
 0   1   2   3   4   5   6
-6  -5  -4  -3  -2  -1

आरेख से, मैं होने की उम्मीद a[-4,-6,-1]करता हूं yPलेकिन यह है ty।

>>> a = "Python"
>>> a[2:4:1] # as expected
'th'
>>> a[-4:-6:-1] # off by 1
'ty'

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

इस तरह, मैं के बारे में सोच सकते हैं a[-4:-6:-1]के रूप में a(-6,-4]अंतराल शब्दावली में।

 +---+---+---+---+---+---+
 | P | y | t | h | o | n |
 +---+---+---+---+---+---+
   0   1   2   3   4   5  
  -6  -5  -4  -3  -2  -1

 +---+---+---+---+---+---+---+---+---+---+---+---+
 | P | y | t | h | o | n | P | y | t | h | o | n |
 +---+---+---+---+---+---+---+---+---+---+---+---+
  -6  -5  -4  -3  -2  -1   0   1   2   3   4   5