Python Language
अनुक्रमण और स्लाइसिंग

वाक्य - विन्यास

• obj [शुरू: स्टॉप: कदम]
• टुकड़ा (बंद)
• टुकड़ा (प्रारंभ, रोक [, कदम])

पैरामीटर

टिप्पणियों

मूल टुकड़ा करना

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

टुकड़ा करने की क्रिया के लिए प्रारूप:

iterable_name[start:stop:step]

कहाँ पे,

• start स्लाइस का पहला सूचकांक है। 0 से चूक (पहले तत्व का सूचकांक)
• स्लाइस के आखिरी इंडेक्स में से एक को stop । लेन के लिए चूक (चलने योग्य)
• step स्टेप साइज है (नीचे दिए गए उदाहरणों से बेहतर बताया गया है)

उदाहरण:

a = "abcdef"
a            # "abcdef" 
             # Same as a[:] or a[::] since it uses the defaults for all three indices
a[-1]        # "f"
a[:]         # "abcdef" 
a[::]        # "abcdef" 
a[3:]        # "def" (from index 3, to end(defaults to size of iterable)) 
a[:4]        # "abcd" (from beginning(default 0) to position 4 (excluded)) 
a[2:4]       # "cd" (from position 2, to position 4 (excluded)) 

इसके अलावा, उपरोक्त किसी भी चरण को परिभाषित आकार के साथ इस्तेमाल किया जा सकता है:

a[::2]       # "ace" (every 2nd element)
a[1:4:2]     # "bd" (from index 1, to index 4 (excluded), every 2nd element)

संकेत नकारात्मक हो सकते हैं, जिस स्थिति में वे अनुक्रम के अंत से गणना करते हैं

a[:-1]     # "abcde" (from index 0 (default), to the second last element (last element - 1))
a[:-2]     # "abcd" (from index 0 (default), to the third last element (last element -2))
a[-1:]     # "f" (from the last element to the end (default len()) 

चरण आकार भी नकारात्मक हो सकते हैं, जिस स्थिति में स्लाइस रिवर्स ऑर्डर में सूची के माध्यम से पुनरावृत्ति करेगा:

a[3:1:-1]   # "dc" (from index 2 to None (default), in reverse order)

यह निर्माण एक पुनरावृत्त को उलटने के लिए उपयोगी है

a[::-1]     # "fedcba" (from last element (default len()-1), to first, in reverse order(-1))

ध्यान दें कि डिफ़ॉल्ट चरणों के लिए डिफ़ॉल्ट end_index None (देखें http://stackoverflow.com/a/12521981 )

a[5:None:-1] # "fedcba" (this is equivalent to a[::-1])
a[5:0:-1]    # "fedcb" (from the last element (index 5) to second element (index 1)

किसी सरणी की उथली प्रतिलिपि बनाना

एक सरणी की एक प्रतिलिपि बनाने का एक त्वरित तरीका (मूल सरणी के लिए एक और संदर्भ के साथ एक चर निर्दिष्ट करने का विरोध किया गया है) है:

arr[:]

सिंटैक्स की जांच करते हैं। [:] अर्थ है कि start , end और slice सभी छूट गए हैं। वे क्रमशः 0 , len(arr) , और 1 लिए डिफ़ॉल्ट होते हैं, जिसका अर्थ है कि हम जो निवेदन कर रहे हैं, वह शुरू से ही बहुत अंत तक arr सभी तत्वों का होगा।

व्यवहार में, यह कुछ इस तरह दिखता है:

arr = ['a', 'b', 'c']
copy = arr[:]
arr.append('d')
print(arr)    # ['a', 'b', 'c', 'd']
print(copy)   # ['a', 'b', 'c']

आप देख सकते हैं, arr.append('d') जोड़ा d के arr , लेकिन copy कोई परिवर्तन नहीं हुआ!

ध्यान दें कि यह उथली प्रतिलिपि बनाता है, और arr.copy() समान है।

किसी वस्तु को उलट देना

आप स्लाइस का उपयोग बहुत आसानी से एक str , list , या tuple (या मूल रूप से किसी भी संग्रह ऑब्जेक्ट जो स्टेप पैरामीटर के साथ स्लाइसिंग लागू करता है) को उल्टा करने के लिए कर सकते हैं। यहां एक स्ट्रिंग को उलटने का एक उदाहरण दिया गया है, हालांकि यह ऊपर सूचीबद्ध अन्य प्रकारों पर समान रूप से लागू होता है:

s = 'reverse me!'
s[::-1]    # '!em esrever'

आइए जल्दी से वाक्य विन्यास को देखें। [::-1] का मतलब है कि टुकड़ा स्ट्रिंग (क्योंकि के अंत तक शुरू से ही होना चाहिए start और end छोड़े गए हैं) और के एक कदम -1 का मतलब है कि यह रिवर्स में स्ट्रिंग के माध्यम से आगे बढ़ना चाहिए।

अनुक्रमणिका कस्टम कक्षाएं: __getitem__, __setitem__ और __delitem__

class MultiIndexingList:
    def __init__(self, value):
        self.value = value
        
    def __repr__(self):
        return repr(self.value)
    
    def __getitem__(self, item):
        if isinstance(item, (int, slice)):
            return self.__class__(self.value[item])
        return [self.value[i] for i in item]
    
    def __setitem__(self, item, value):
        if isinstance(item, int):
            self.value[item] = value
        elif isinstance(item, slice):
            raise ValueError('Cannot interpret slice with multiindexing')
        else:
            for i in item:
                if isinstance(i, slice):
                    raise ValueError('Cannot interpret slice with multiindexing')
                self.value[i] = value
    
    def __delitem__(self, item):
        if isinstance(item, int):
            del self.value[item]
        elif isinstance(item, slice):
            del self.value[item]
        else:
            if any(isinstance(elem, slice) for elem in item):
                raise ValueError('Cannot interpret slice with multiindexing')
            item = sorted(item, reverse=True)
            for elem in item:
                del self.value[elem]

यह तत्व की पहुंच के लिए टुकड़ा करने की क्रिया और अनुक्रमण की अनुमति देता है:

a = MultiIndexingList([1,2,3,4,5,6,7,8])
a
# Out: [1, 2, 3, 4, 5, 6, 7, 8]
a[1,5,2,6,1]
# Out: [2, 6, 3, 7, 2]
a[4, 1, 5:, 2, ::2]
# Out: [5, 2, [6, 7, 8], 3, [1, 3, 5, 7]]
#       4|1-|----50:---|2-|-----::2-----   <-- indicated which element came from which index

तत्वों को स्थापित करने और हटाने के दौरान केवल अल्पविराम से पूर्णांक अनुक्रमण (कोई टुकड़ा करना) के लिए अनुमति देता है:

a[4] = 1000
a
# Out: [1, 2, 3, 4, 1000, 6, 7, 8]
a[2,6,1] = 100
a
# Out: [1, 100, 100, 4, 1000, 6, 100, 8]
del a[5]
a
# Out: [1, 100, 100, 4, 1000, 100, 8]
del a[4,2,5]
a
# Out: [1, 100, 4, 8]

स्लाइस असाइनमेंट

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

इसका मतलब है कि यदि आपके पास एक सूची है, तो आप एक ही असाइनमेंट में कई सदस्यों को बदल सकते हैं:

lst = [1, 2, 3]
lst[1:3] = [4, 5]
print(lst) # Out: [1, 4, 5]

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

lst = [1, 2, 3, 4, 5]
lst[1:4] = [6]
print(lst) # Out: [1, 6, 5]

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

lst = [1, 2, 3]
lst[:] = [4, 5, 6]
print(lst) # Out: [4, 5, 6]

या सिर्फ अंतिम दो सदस्य:

lst = [1, 2, 3]
lst[-2:] = [4, 5, 6]
print(lst) # Out: [1, 4, 5, 6]

वस्तुओं का टुकड़ा

स्लाइस अपने आप में वस्तुएं हैं और इन-बिल्ट slice() फ़ंक्शन के साथ चर में संग्रहीत किया जा सकता है। आपके कोड को अधिक पठनीय बनाने और पुन: उपयोग को बढ़ावा देने के लिए स्लाइस चर का उपयोग किया जा सकता है।

>>> programmer_1 = [ 1956, 'Guido', 'van Rossum', 'Python', 'Netherlands']
>>> programmer_2 = [ 1815, 'Ada', 'Lovelace', 'Analytical Engine', 'England']
>>> name_columns = slice(1, 3)
>>> programmer_1[name_columns]
['Guido', 'van Rossum']
>>> programmer_2[name_columns]
['Ada', 'Lovelace']

मूल अनुक्रमण

पायथन लिस्ट 0-आधारित हैं यानी लिस्ट में पहले तत्व को इंडेक्स 0 द्वारा एक्सेस किया जा सकता है

arr = ['a', 'b', 'c', 'd']
print(arr[0])
>> 'a'

आप सूची में दूसरे तत्व को इंडेक्स 1 , तीसरे तत्व द्वारा इंडेक्स 2 और इसी तरह एक्सेस कर सकते हैं:

print(arr[1])
>> 'b'
print(arr[2])
>> 'c'

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

print(arr[-1])
>> 'd'
print(arr[-2])
>> 'c'

यदि आप एक इंडेक्स तक पहुंचने का प्रयास करते हैं, जो सूची में मौजूद नहीं है, तो एक IndexError उठाया जाएगा:

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