दिलचस्प पोस्ट
कई बहुआयामी ggplot2 ग्राफिक्स में समान पहलू आकार और तराजू कैसे प्राप्त करें? बाहरी। जावा के साथ जावा कमांड लाइन समाप्त होता है जावास्क्रिप्ट में आईसीयू का निर्माण कैसे करें, तो मैं इसे आईफोन ऐप में इस्तेमाल कर सकता हूं? जावा का समर्थन अहस्ताक्षरित ints क्यों नहीं करता है? अजगर में एक फ़ाइल का माइम प्रकार कैसे पाता है? कैसे मौजूदा, unpushed प्रतिबद्धों को संशोधित करने के लिए? सशर्त क्षेत्र सत्यापन जो किसी अन्य क्षेत्र पर निर्भर करता है java.lang.IllegalArgumentException: और नामक सर्वलेट यूआरएल-पैटर्न के लिए मैप किए जाते हैं, जिन्हें अनुमति नहीं है कोणीय 2 @ViewChild एनोटेशन रिटर्न अनिर्धारित ऐप स्टोर मुद्दे पर सबमिट करें: असमर्थित आर्किटेक्चर x86 GitHub रेपो से एक फ़ोल्डर या निर्देशिका डाउनलोड करें मैं एक जेएक्स-डब्लूएस अनुरोध के लिए एक सिस्टम प्रॉपर प्रॉपर्टी सेट किए बिना कैसे एक HTTP प्रॉक्सी का उपयोग कर सकता हूं? आर में, किसी फ़ंक्शन पर भेजे जाने के बाद ऑब्जेक्ट का नाम कैसे प्राप्त करें? मैं जावा 8 स्ट्रीमों के अंदर से अपवादों को कैसे रोक सकता हूं? (इसे अनियंत्रित अपवादों में लपेटकर नहीं)

पायथन के टुकड़ा नोटेशन को समझना

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

मेरे लिए, इस नोटेशन को चुनने की थोड़ी जरूरत है

यह बहुत शक्तिशाली लग रहा है, लेकिन मुझे इसके आसपास मेरे सिर काफी नहीं मिला है।

Solutions Collecting From Web of "पायथन के टुकड़ा नोटेशन को समझना"

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

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

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

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

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

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

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

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

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

एएससीआईआई कला आरेख बहुत याद रखने के लिए सहायक होता है कि स्लाइस कैसे काम करते हैं:

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

स्लाइड्स के कामों को याद करने का एक तरीका है कि वर्णों के बीच की ओर इशारा करते हुए इंडेक्सों के बारे में सोचने के लिए, पहले वर्ण के बायीं किनारे के साथ 0 गिने जाते हैं। फिर एन वर्णों की एक स्ट्रिंग के अंतिम चरित्र का दाहिना किनारा सूचकांक n है

व्याकरण की अनुमतियों की गणना करना:

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

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

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

ऊपर दिए गए उत्तर स्लाइस असाइनमेंट पर चर्चा नहीं करते हैं:

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

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

अजगर का टुकड़ा नोटेशन समझाओ

संक्षेप में, सबस्क्रिप्ट नोटेशन ( 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.clearlist.clear विधि मिलता है।)

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

आपको इसे टुकड़ा को list.__getitem__ जाने से अलग करने में उपयोगी हो सकता है 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] 

स्मृति विचार:

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

 >>> length = 100 >>> last_nine_iter = itertools.islice(list(range(length)), length-9, None, 1) >>> list_last_nine = list(last_nine) >>> list_last_nine [91, 92, 93, 94, 95, 96, 97, 98, 99] 

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

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

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

इस महान तालिका को http://wiki.python.org/moin/MovingToPython पर पाया गया ।

 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) 

पायथन 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 (आगे या पिछड़े) के हस्ताक्षर के आधार पर कह रहे हैं, ख (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 astring -9 -8 -7 -6 -5 -4 -3 -2 -1 

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

एक आखिरी चीज: यदि ए और बी समान हैं, तो आपको खाली सूची भी मिलती है:

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

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

 (from:to:step) 

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

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

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

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

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

यह 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() (देखें भी reversed() ।)

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

TODO : नीचे दिए गए कोड में "कभी क्रम से बाहर नहीं जाना" जब abs (चरण)> 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 विवरण is None – बस याद रखें कि start और / या stop हमेशा आपको पूरी अनुक्रम देने के लिए सही काम करता है।

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

 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

पायथन टुकड़ा करने की क्रिया संकेतन:

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

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

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

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

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

 mylist[X:Y] 

एक्स आप चाहते हैं कि पहले तत्व का सूचकांक है।
वाई आपको पहले तत्व का सूचक नहीं है जिसे आप नहीं चाहते हैं।

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

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

ऊपर एबीसी के उत्तर देखें

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

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

इस तरह मैं नए लोगों को स्लाइस सिखाता हूं:

अनुक्रमण और टुकड़ों के बीच अंतर को समझना:

विकी पायथन में यह आश्चर्यजनक तस्वीर है जो स्पष्ट रूप से अनुक्रमण और टुकड़ा करने की क्रिया को अलग करती है।

यहां छवि विवरण दर्ज करें

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

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

 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 

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

आप पहले 3 बक्से या पिछली 2 बक्से या 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 के स्रोत कोड की जांच करते हैं, तो आप पाइस्लिस_गेट इंडीडेसएक्स नामक फ़ंक्शन पायेंगे, जो किसी भी पैरामीटर के लिए एक टुकड़े के सूचकांक को दर्शाता है। यहाँ पायथन में तार्किक समकक्ष कोड है

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

 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] 

नोट: यह पोस्ट मूल रूप से मेरे ब्लॉग में लिखा गया है http://www.avilpage.com/2015/03/a-slice-of-python-intelligence-behind.html

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

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

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

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

 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 returns the last 5 elements s[:-5] # start at index 0, end until the 5th index from end of array, # thus returns s[0:len(s)-5] 

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

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

नकारात्मक कदम का मतलब है कि पीछे की ओर सरंचना: अंत से शुरू करने के साथ, समाप्ति सूचकांक के साथ, और परिणामी से बहिष्कृत सूचकांक शुरू करें

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

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

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

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

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

 s[:len(s)+5] # same as s[:len(s)] s[-len(s)-5::] # same as s[0:] s[len(s)+5::-1] # same as s[len(s)::-1], 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, 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 IndexError --------------------------------------------------------------------------- IndexError Traceback (most recent call last) <ipython-input-15-79ffc22473a3> in <module>() ----> 1 s[11] IndexError: list index out of range 

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

लेकिन कभी-कभी इसमें संदेह होता है कि मेरा मस्तिष्क आश्वासन देता है कि इसमें end -तत्व नहीं है।

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

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

यह सुंदर संपत्ति मुझसे कहती है कि lst[start:end] में end वस्तु नहीं होती है क्योंकि यह सबसे ऊपर है lst[end:]

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

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

रिटर्न True

ऊपर दिए गए उत्तर मल्टी-डायमेंशनल ऐले स्कीइसिंग पर चर्चा नहीं करते हैं जो कि प्रसिद्ध नोडी पैकेज का उपयोग कर संभव है:

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

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

एक पुनरावृत्ति (एक सूची की तरह) का एक निश्चित टुकड़ा प्राप्त करने के लिए, यहां एक उदाहरण है:

 variable[number1:number2] 

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

 #!/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) 

You can run this script and experiment with it, below is some samples that I got from the script.

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

When using a negative step, notice that the answer is shifted to the right by 1.

In Python, the most basic form for slicing is the following:

l[start:end]

where l is some collection, start is an inclusive index and end is an exclusive index.

 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] 

When slicing from start, you can omit the zero index, and when slicing to the end, you can omit the final index since it is redundant, so do not be verbose:

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

Negative integers are useful when doing offsets relative to the end of a collection:

 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 3 elements Out[8]: [7, 8, 9] 

It is possible to provide indices that are out of bounds when slicing such as:

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

Keep in mind that the result of slicing a collection is a whole new collection. In addition, when using slice notation in assignments, the length of the slice assignment do not need to be the same. The values before and after the assigned slice will be kept, and the collection will shrink or grow to contain the new values:

 In [16]: l[2:6] = list('abc') # assigning less 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] 

If you omit the start and end index, you will make a copy of the collection:

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

If the start and end indexes are omitted when performing an assignment operation, the entire content of the collection will be replaced with a copy of what is referenced:

 In [20]: l[:] = list('hello...') In [21]: l Out[21]: ['h', 'e', 'l', 'l', 'o', '.', '.', '.'] 

Besides basic slicing, it is also possible to apply the following notation:

 l[start:end:step] 

where l is a collection, start is an inclusive index, end is an exclusive index, and step is a stride that can be used to take every nth item in 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] 

Using step provides a useful trick to reverse a collection in Python:

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

It is also possible to use negative integers for step as the following example:

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

However, using a negative value for step could become very confusing. Moreover, in order to be Pythonic, you should avoid using start , end , and step in a single slice. In case this is required, consider doing this in two assignments (one to slice, and the other to stride).

 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] 

The below is the example of index of a string

  +---+---+---+---+---+ | H | e | l | p | A | +---+---+---+---+---+ 0 1 2 3 4 5 -5 -4 -3 -2 -1 str="Name string" 

slicing example: [start:end:step]

 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 

Below is the example usage

 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 

Most of the above answers clears about Slice notation. Extended indexing syntax used for slicing is aList[start:stop:step] basic examples are

यहां छवि विवरण दर्ज करें :

More Slicing examples: 15 Extended Slices