जब अनुक्रमों को कम कर रहा है तो पायथन में :: (डबल कोलन) क्या है?

Question

मुझे पता है कि मैं string[3:4]पायथन में एक विकल्प प्राप्त करने के लिए कुछ का उपयोग कर सकता हूं , लेकिन 3 का क्या अर्थ है somesequence[::3]?

Comments

इसका क्या मतलब है जो पहले आता है :: जैसे [5::]। तो इसका 5 से क्या मतलब है?

— उमर असग़र

[५ ::] का मतलब पहले तत्व से शुरू होगा, दूसरे के लिए कुछ नहीं और अगले तत्व का चयन करें

— गगन

Answer 1

इसका अर्थ है 'पहले तर्क के लिए कुछ नहीं, दूसरे के लिए कुछ नहीं और तीन से कूदो'। यह अनुक्रम का हर तीसरा आइटम कटा हुआ मिलता है। विस्तारित स्लाइस वही है जो आप चाहते हैं। पायथन 2.3 में नया

Comments

इसका उपयोग किसी सूची को उलटने के लिए भी किया जा सकता है [:: - 1]

— thavan

यह प्रत्येक आइटम को उस स्थिति पर लौटाता है जो 3 से अधिक है । 3 * 0 = 0 के बाद से, यह भी आइटम 0. स्थिति पर लौटाता है। उदाहरण के लिए: range(10)[::3]आउटपुट[0, 3, 6, 9]

— रिकी रॉबिन्सन

इसका क्या मतलब है जो पहले की ::तरह आता है [n ::]। तो इसका क्या मतलब है n?

— उमर असगर

Answer 2

पायथन सीक्वेंस स्लाइस पतों को एक [स्टार्ट: एंड: स्टेप] के रूप में लिखा जा सकता है और किसी भी शुरुआत, स्टॉप या एंड को गिराया जा सकता है। a[::3]अनुक्रम का हर तीसरा तत्व है।

Answer 3

seq[::n]nपूरे क्रम में प्रत्येक -th आइटम का एक क्रम है।

उदाहरण:

>>> range(10)[::2]
[0, 2, 4, 6, 8]

वाक्य रचना है:

seq[start:end:step]

तो आप कर सकते हैं:

>>> range(100)[5:18:2]
[5, 7, 9, 11, 13, 15, 17]

Comments

पायथन 3 में, आपकी उदाहरण श्रेणी (N) [:: step] एक श्रेणी ऑब्जेक्ट का उत्पादन करती है, न कि सूची की। वास्तव में यह देखने के लिए कि क्या हो रहा है, आपको सीमा को एक सूची, np.array, इत्यादि में ले जाने की आवश्यकता है

— PikalaxALT

Answer 4

व्याख्या

s[i:j:k], है दस्तावेज़ के अनुसार , "कदम कश्मीर के साथ जे करने के लिए मैं से एस के स्लाइस"। जब iऔर jअनुपस्थित होते हैं, तो पूरे अनुक्रम को ग्रहण किया जाता है और इस प्रकार s[::k]"हर के-वें आइटम" का अर्थ होता है।

उदाहरण

सबसे पहले, आइए एक सूची आरंभ करें:

>>> s = range(20)
>>> s
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]

आइए प्रत्येक 3 ^rd आइटम को sनिम्न से लें :

>>> s[::3]
[0, 3, 6, 9, 12, 15, 18]

आइए प्रत्येक 3 ^rd आइटम को s[2:]निम्न से लें :

>>> s[2:]
[2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
>>> s[2::3]
[2, 5, 8, 11, 14, 17]

आइए प्रत्येक 3 ^rd आइटम को s[5:12]निम्न से लें :

>>> s[5:12]
[5, 6, 7, 8, 9, 10, 11]
>>> s[5:12:3]
[5, 8, 11]

आइए प्रत्येक 3 ^rd आइटम को s[:10]निम्न से लें :

>>> s[:10]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> s[:10:3]
[0, 3, 6, 9]

Comments

अद्भुत जवाब!

— जर्गेन के।

Answer 5

टी एल; डॉ

यह दृश्य उदाहरण आपको बताएगा कि एक सुंदर मनोरंजक तरीके (एक वादा) में एक न्यूमप मैट्रिक्स (2 आयामी सरणी) में बड़े करीने से चयन करने वाले तत्व कैसे हैं। नीचे दिए गए चरण 2 ::प्रश्न में उस "डबल कॉलन" के उपयोग का वर्णन करें ।

(सावधानी: ::कई कुल्हाड़ियों में तत्वों के कूदने के लिए "डबल कॉलन" के उपयोग के मामले को दर्शाने के उद्देश्य से यह एक नम्पी सरणी विशिष्ट उदाहरण है । यह उदाहरण मूल पायथन डेटा संरचनाओं को कवर नहीं करता है List)।

उन सभी पर शासन करने के लिए एक ठोस उदाहरण ...

मान लें कि हमारे पास एक NumPy मैट्रिक्स है जो इस तरह दिखता है:

In [1]: import numpy as np

In [2]: X = np.arange(100).reshape(10,10)

In [3]: X
Out[3]:
array([[ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9],
       [10, 11, 12, 13, 14, 15, 16, 17, 18, 19],
       [20, 21, 22, 23, 24, 25, 26, 27, 28, 29],
       [30, 31, 32, 33, 34, 35, 36, 37, 38, 39],
       [40, 41, 42, 43, 44, 45, 46, 47, 48, 49],
       [50, 51, 52, 53, 54, 55, 56, 57, 58, 59],
       [60, 61, 62, 63, 64, 65, 66, 67, 68, 69],
       [70, 71, 72, 73, 74, 75, 76, 77, 78, 79],
       [80, 81, 82, 83, 84, 85, 86, 87, 88, 89],
       [90, 91, 92, 93, 94, 95, 96, 97, 98, 99]])

किसी कारण से कहें, आपका बॉस चाहता है कि आप निम्नलिखित तत्वों का चयन करें:

"लेकिन कैसे ???" ... पर पढ़ें! (हम इसे 2-चरणीय दृष्टिकोण में कर सकते हैं)

चरण 1 - सबसेट प्राप्त करें

पंक्ति-वार और कॉलम-वार दोनों दिशाओं में "स्टार्ट इंडेक्स" और "एंड इंडेक्स" निर्दिष्ट करें।

कोड में:

In [5]: X2 = X[2:9,3:8]

In [6]: X2
Out[6]:
array([[23, 24, 25, 26, 27],
       [33, 34, 35, 36, 37],
       [43, 44, 45, 46, 47],
       [53, 54, 55, 56, 57],
       [63, 64, 65, 66, 67],
       [73, 74, 75, 76, 77],
       [83, 84, 85, 86, 87]])

ध्यान दें कि अभी हमने सरल शुरुआत और अंत इंडेक्सिंग तकनीक के उपयोग के साथ, हमारा सबसेट प्राप्त किया है। अगला, कैसे करें कि "कूद" ... (पढ़ें!)

चरण 2 - तत्वों का चयन करें ("कूद कदम" तर्क के साथ)

अब हम पंक्ति-वार और कॉलम-वार दिशाओं में "जंप स्टेप्स" निर्दिष्ट कर सकते हैं ("जंपिंग" तरीके से तत्वों का चयन करने के लिए) जैसे:

कोड में (दोहरे कॉलनों पर ध्यान दें):

In [7]: X3 = X2[::3, ::2]

In [8]: X3
Out[8]:
array([[23, 25, 27],
       [53, 55, 57],
       [83, 85, 87]])

हमने आवश्यकतानुसार सभी तत्वों का चयन किया है! :)

 समेकित चरण 1 (आरंभ और अंत) और चरण 2 ("कूद")

अब हम अवधारणा को जानते हैं, हम आसानी से चरण 1 और चरण 2 को एक समेकित चरण में जोड़ सकते हैं - कॉम्पैक्टनेस के लिए:

In [9]: X4 = X[2:9,3:8][::3,::2]

    In [10]: X4
    Out[10]:
    array([[23, 25, 27],
           [53, 55, 57],
           [83, 85, 87]])

किया हुआ!

Comments

क्या होगा यदि मैं उन चिह्नित प्रविष्टियों में से प्रत्येक को मूल ऑब्जेक्ट में 0 पर सेट करना चाहता हूं? कैसे आगे बढ़ा जाए?

— user1211030

एक करें X[2:9,3:8][::3,::2] = 0 (चिह्नित प्रविष्टियों को 0 में बदलने के लिए)। यदि आप Xफिर से टाइप करते हैं तो आप देखेंगे कि उन सभी चिन्हित प्रविष्टियों को अब सेट कर दिया गया है 0।

— एटलस

Answer 6

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

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

>>> '123123123'[::3]
'111'

Answer 7

आप इस संकेतन का उपयोग अपनी स्वयं की कस्टम कक्षाओं में भी कर सकते हैं ताकि आप जो चाहें कर सकें

class C(object):
    def __getitem__(self, k):
        return k

# Single argument is passed directly.
assert C()[0] == 0

# Multiple indices generate a tuple.
assert C()[0, 1] == (0, 1)

# Slice notation generates a slice object.
assert C()[1:2:3] == slice(1, 2, 3)

# If you omit any part of the slice notation, it becomes None.
assert C()[:] == slice(None, None, None)
assert C()[::] == slice(None, None, None)
assert C()[1::] == slice(1, None, None)
assert C()[:2:] == slice(None, 2, None)
assert C()[::3] == slice(None, None, 3)

# Tuple with a slice object:
assert C()[:, 1] == (slice(None, None, None), 1)

# Ellipsis class object.
assert C()[...] == Ellipsis

हम इसके बाद स्लाइस ऑब्जेक्ट्स को खोल सकते हैं:

s = slice(1, 2, 3)
assert s.start == 1
assert s.stop == 2
assert s.step == 3

यह किसी भी दिशा में बहु-आयामी सरणियों का टुकड़ा करने के लिए Numpy में विशेष रूप से उपयोग किया जाता है।

बेशक, किसी भी समझदार एपीआई को ::3सामान्य "हर 3" शब्दार्थ के साथ उपयोग करना चाहिए ।

संबंधित Ellipsisको आगे कवर किया गया है: एलिप्सिस ऑब्जेक्ट क्या करता है?

Answer 8

तीसरा पैरामीटर चरण है। इसलिए [:: 3] सूची / स्ट्रिंग के प्रत्येक 3 तत्व को वापस करेगा।

Answer 9

पायथन अंत, प्रारंभ और चरण मान को अलग करने के लिए :: का उपयोग करता है।

Comments

यह वास्तव में सहायक होने के लिए पर्याप्त विवरण प्रदान नहीं करता है।

— 12

क्या आपका मतलब "स्टार्ट, द एंड और स्टेप" नहीं है? उन्हें आदेश से बाहर निकालने के लिए भ्रामक लगता है।

— जॉन Coombs