सवाल पायथन के स्लाइस नोटेशन को समझना


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

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

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


2300
2018-02-03 22:31


मूल




जवाब:


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

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 मान पहले मान का प्रतिनिधित्व करता है नहीं चयनित टुकड़ा में। तो, अंतर बीच 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

इसी तरह, 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 केवल एक तत्व होता है, आपको किसी त्रुटि के बजाय खाली सूची मिलती है। कभी-कभी आप त्रुटि को प्राथमिकता देते हैं, इसलिए आपको यह पता होना चाहिए कि ऐसा हो सकता है।


3112
2018-02-03 22:48



स्लाइसिंग बिल्टिन प्रकार एक प्रतिलिपि देता है लेकिन यह सार्वभौमिक नहीं है। विशेष रूप से, NumPy सरणी slicing एक दृश्य देता है जो मूल के साथ स्मृति साझा करता है। - Beni Cherniavsky-Paskin
यह क्या करेगा? [::-2]  मैंने कोशिश की है लेकिन मुझे समझ में नहीं आया। उदाहरण के लिए इस सूची के साथ a = ['1', '2', '3', '4', '5'] । - RodriKing


पायथन ट्यूटोरियल इसके बारे में बात करते हैं (जब तक आप स्लाइसिंग के बारे में भाग नहीं लेते तब तक नीचे स्क्रॉल करें)।

एएससीआईआई आर्ट आरेख भी स्लाइस काम करने के तरीके को याद रखने में मददगार है:

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

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


395
2018-02-03 22:49



नकारात्मक कदमों के साथ स्लाइस के लिए, मुझे यह एएससीआईआई कला उलझन में मिलती है, और इसे विस्तारित करना चाहिए -6 जबसे 'ApleH'[:-6:-1] एक वैध टुकड़ा है और उपयोग करने से अलग है -5 - Chris_Rands
"यह याद रखने का एक तरीका है कि स्लाइस कैसे काम करते हैं, सूचकांक के बीच संकेतों के बारे में सोचने के लिए" - यह इसके बारे में सोचने का एक शानदार तरीका है - jusopi


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

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

310
2018-02-03 23:08



कुछ अजीब होता है अगर stride के रूप में नकारात्मक है [::-1]? - Charlie Parker
@ चार्लीपार्कर कब strike नकारात्मक है यह से गिना जाता है high सेवा मेरे low। - ephemient
वास्तव में अभी भी कुछ छोड़ दिया गया है उदा। अगर मैं 'सेब' टाइप करता हूं [4: -4: -1] मुझे 'elp' मिलता है, तो अजगर -4 से 1 तक अनुवाद कर रहा है? - liyuan


उपरोक्त उत्तरों स्लाइस असाइनमेंट पर चर्चा नहीं करते हैं:

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

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


199
2018-01-18 21:37



क्या आप दूसरे को समझा सकते हैं? - chandresh


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

संक्षेप में, कोलन (:) सबस्क्रिप्ट नोटेशन में (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, चालू")

स्पष्टीकरण:

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

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

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

इस प्रकार एक नकारात्मक टुकड़ा डिफ़ॉल्ट के लिए डिफ़ॉल्ट बदल जाएगा 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, इसलिए यदि यह कोई मुद्दा है तो आपको सूचकांक की गणना करने या अग्रिम में पुनरावर्तित करने की आवश्यकता हो सकती है।

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]

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


186
2017-07-12 13:19



हाय @ हारनहॉल, उत्कृष्ट पोस्ट! क्या आप इस पोस्ट को इंटरमीडिएट पायथन पुस्तक में योगदान देने पर विचार करेंगे - github.com/yasoob/intermediatePython/issues/153 ? - neowulf33
बस इस पोस्ट के लिए आपको बहुत धन्यवाद कहना चाहता था, मैं थोड़ी देर के लिए पाइथन लिख रहा हूं और अभी भी इस पर वापस आ गया हूं क्योंकि मैं हर बार एक त्रुटि से टुकड़ा कर रहा हूं! - akkatracker
यहां सबसे अच्छा जवाब है - kskyriacou


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

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

124
2018-02-03 23:15





इस महान मेज पर मिला 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)

84
2017-09-06 06:50





पायथन 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

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

-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

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

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

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

84
2017-10-22 05:33



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


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

(from:to:step)

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

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

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

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


47
2018-02-19 20:52





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

समझने के लिए यह निर्देशक है 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()।)

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

करने के लिए: नीचे दिए गए कोड में "अनुक्रम के बाहर कभी नहीं जाना" के साथ एक बग था जब पेट (चरण)> 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] बस पूरी स्ट्रिंग है।


32
2018-03-29 10:15



this_is_how_slicing_works पाइथन टुकड़ा के समान नहीं है। E.G. [0, 1, 2][-5:3:3] पाइथन में [0] मिलेगा, लेकिन list(this_is_how_slicing_works([0, 1, 2], -5, 3, 3)) [1] प्राप्त करें। - Eastsun
@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 के लिए गलत है। मैं इसे बाद में (परीक्षण के साथ) फिर से लिखूंगा। - Beni Cherniavsky-Paskin


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

mylist[X:Y]

एक्स आपके इच्छित तत्व का सूचकांक है।
वाई आपके पहले तत्व की अनुक्रमणिका है नहीं चाहते हैं।


31
2018-02-06 21:16