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

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

जब step नकारात्मक होता है, तो start और stop चेंज के लिए डिफ़ॉल्ट

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

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

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

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

मैं उपयोगकर्ताओं को स्रोत और दस्तावेज़ीकरण को पढ़ने के लिए प्रोत्साहित करना चाहता हूं। स्लाइस ऑब्जेक्ट्स के लिए स्रोत कोड और यह तर्क यहां पाया जाता है । सबसे पहले हम निर्धारित करते हैं कि 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 लिए डिफ़ॉल्ट लागू करने की आवश्यकता हो सकती है - डिफ़ॉल्ट के बाद डिफ़ॉल्ट को ऊपरी बाउंड के रूप में गणना की जाती है जब 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__ पास करने से अलग करने के लिए उपयोगी लग सकता है list.__getitem__ विधि ( यही वर्ग वर्ग ब्रैकेट करता है )। यहां तक ​​कि यदि आप इसके लिए नए नहीं हैं, तो यह आपके कोड को और अधिक पठनीय रखता है ताकि अन्य लोगों को जो आपका कोड पढ़ना पड़े, वे आसानी से समझ सकें कि आप क्या कर रहे हैं।

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

last_nine_slice = slice(-9, None)

दूसरा तर्क, None , आवश्यक है, ताकि पहला तर्क start तर्क के रूप में व्याख्या किया गया 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 करने के start नकारात्मक तर्कों का समर्थन नहीं करता है, इसलिए यदि यह कोई समस्या है तो आपको सूचकांक की गणना करने या अग्रिम में पुन: प्रयास करने की आवश्यकता हो सकती है।

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]

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

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

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

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

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

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

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

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

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

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

दिलचस्प बात यह है कि आप एक साथ कई बॉक्स को प्रतिस्थापित कर सकते हैं। साथ ही आप जहां भी चाहें कई बॉक्स रख सकते हैं।

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

चरण के साथ slicing:

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

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

कैसे पाइथन गुम पैरामीटर बाहर आंकड़े:

जब आप कोई पैरामीटर छोड़ते हैं तो टुकड़ा करते समय, पायथन स्वचालित रूप से इसे निकालने का प्रयास करता है।

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

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

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

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

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

(from:to:step)

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

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

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

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

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

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

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

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

पायथन स्लाइसिंग नोटेशन:

a[start:end:step]

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

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

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

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

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

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 विवरण is None - बस याद रखें कि start छोड़ना और / या हमेशा आपको पूरे अनुक्रम देने के लिए सही चीज है।

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

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

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

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

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]

ऊपर एबीसी का जवाब देखें

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

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

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

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

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

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

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

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

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

कॉमा पहले आयाम पर काम करता है और "0: 3: 2" कोमा के बाद दूसरे आयाम पर काम करता है।

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

variable[number1:number2]

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

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

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

ऐसे सूचकांक प्रदान करना संभव है जो इस तरह के टुकड़े टुकड़े करते समय सीमा से बाहर हैं:

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]

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

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]

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

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]

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

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

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

A = list(range(1,10,1)) # start,stop,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:step]मूल उदाहरण हैं

:

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

मेरा मस्तिष्क स्वीकार करने में प्रसन्नता करता है 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।

यदि आपको लगता है कि स्लाइसिंग में नकारात्मक सूचकांक उलझन में हैं, तो इसके बारे में सोचने का बहुत आसान तरीका यहां है: केवल नकारात्मक इंडेक्स को प्रतिस्थापित करें 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 for-loop with start, end and step
  return [list[i] for i in range(start, end, step)]

#!/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 में स्थानांतरित किया गया है।