दिलचस्प पोस्ट
सलाख़ी कुंजी के साथ कछुआ गिटट एसएसएच-एजेंट का उपयोग प्रमाणीकरण नहीं करता जब मैं session_start () कॉल करता हूं तो मैं अनुमति त्रुटि कैसे ठीक कर सकता हूँ? Sql निर्भरता की सीमाएं क्या हैं क्या मैं एक सेवा को निर्देश में डाल सकता हूं? DOM में परिवर्तन का पता लगाएं लिंक्स जहां सूची में किसी भी सूची शामिल है टेक्स्टव्यू शैली सेट करें (बोल्ड या इटैलिक) पायथन में '@ =' प्रतीक क्या है? Matlab में एक फ़ोल्डर में फ़ाइलों के माध्यम से लूप बैकबोन। देखें "एल" भ्रम Chrome में काम करने के लिए execCommand ('पेस्ट') नहीं मिल सकता NSPopover पर NSTextField को संपादित करने में सक्षम नहीं होने के बावजूद भी संपादन योग्य व्यवहार सेट है पूर्णांक के लिए कारक कन्वर्ट सी ++: वेक्टर <बेस> प्रकार की वस्तुओं को प्राप्त कर सकते हैं? एसएसई आंतरिक कार्यों का संदर्भ

क्या मैं एक "व्यू" एक पायथन सूची पर बना सकता हूं?

मेरे पास एक बड़ी सूची है l मैं तत्व 4 से 6 तक एक दृश्य बनाना चाहता हूं। मैं इसे अनुक्रम स्लाइस के साथ कर सकता हूं।

 >>> l=range(10) >>> lv=l[3:6] >>> lv [3, 4, 5] 

हालांकि एल.वी. एल का एक टुकड़ा है। अगर मैं अंतर्निहित सूची को बदलता हूं, तो एलवी परिवर्तन को प्रतिबिंबित नहीं करता है।

 >>> l[4] = -1 >>> lv [3, 4, 5] 

इसके विपरीत मैं एल.वी. पर संशोधन को एल में प्रतिबिंबित करना चाहता हूं इसके अलावा सूची आकार को परिवर्तित नहीं किया जा रहा है।

मैं ऐसा करने के लिए एक बड़ा वर्ग बनाने के लिए उत्सुक नहीं हूं। मैं सिर्फ अन्य पायथन गुरुओं को उम्मीद कर रहा हूं कि कुछ छिपी हुई भाषा चाल को पता चल सकता है। आदर्श रूप से मुझे उम्मीद है कि यह सी में पॉइंटर अंकगणितीय पसंद कर सकता है।

 int lv[] = l + 3; 

Solutions Collecting From Web of "क्या मैं एक "व्यू" एक पायथन सूची पर बना सकता हूं?"

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

 import collections class ROListSlice(collections.Sequence): def __init__(self, alist, start, alen): self.alist = alist self.start = start self.alen = alen def __len__(self): return self.alen def adj(self, i): if i<0: i += self.alen return i + self.start def __getitem__(self, i): return self.alist[self.adj(i)] 

इसमें कुछ सीमाएं हैं ("एक टुकड़ा टुकड़ा करना" का समर्थन नहीं करता है) लेकिन अधिकांश उद्देश्यों के लिए ठीक हो सकता है

इस क्रम को बनाने के लिए आपको __setitem__ , __delitem__ , और insert :

 class ListSlice(ROListSlice): def __setitem__(self, i, v): self.alist[self.adj(i)] = v def __delitem__(self, i, v): del self.alist[self.adj(i)] self.alen -= 1 def insert(self, i, v): self.alist.insert(self.adj(i), v) self.alen += 1 

शायद सिर्फ एक numpy array का उपयोग करें:

 In [19]: import numpy as np In [20]: l=np.arange(10) 

मूल टुकड़े टुकड़े करने योग्य एरेज़ एक दृश्य देता है , एक प्रति नहीं:

 In [21]: lv=l[3:6] In [22]: lv Out[22]: array([3, 4, 5]) 

परिवर्तन l प्रभावित करता है:

 In [23]: l[4]=-1 In [24]: lv Out[24]: array([ 3, -1, 5]) 

और lv प्रभावित करना l प्रभावित करता है:

 In [25]: lv[1]=4 In [26]: l Out[26]: array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) 

आप मूल सूची संदर्भ का उपयोग करके अपना खुद का जनरेटर बनाकर ऐसा कर सकते हैं।

 l = [1,2,3,4,5] lv = (l[i] for i in range(1,4)) lv.next() # 2 l[2]=-1 lv.next() # -1 lv.next() # 4 

हालांकि यह एक जनरेटर रहा है, आप केवल सूची के माध्यम से एक बार आगे जा सकते हैं और आगे बढ़कर विस्फोट कर सकते हैं यदि आप range से अनुरोध किए गए तत्वों को हटा देते हैं।

संपादित करें: The object argument must be an object that supports the buffer call interface (such as strings, arrays, and buffers). – तो नहीं, दुख की बात है

मुझे लगता है कि बफर प्रकार वह है जिसे आप ढूंढ रहे हैं।

लिंक किए गए पृष्ठ से उदाहरण पेस्ट करना:

 >>> s = bytearray(1000000) # a million zeroed bytes >>> t = buffer(s, 1) # slice cuts off the first byte >>> s[1] = 5 # set the second element in s >>> t[0] # which is now also the first element in t! '\x05' 

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

यदि आप वास्तव में एक परिवर्तनीय दृश्य बनाना चाहते हैं, तो आप collection.MutableSequence आधार पर एक नया वर्ग की कल्पना कर सकते हैं। महत्वपूर्ण सफ़ेदता

यह एक पूर्ण विशेष रुप से उप सूची के लिए एक शुरुआती बिंदु हो सकता है – यह सही ढंग से टुकड़ा अनुक्रमित प्रक्रिया करता है, लेकिन कम से कम ऋणात्मक इंडेक्स प्रसंस्करण के लिए विशिष्टता की कमी है:

 class Sublist(collections.MutableSequence): def __init__(self, ls, beg, end): self.ls = ls self.beg = beg self.end = end def __getitem__(self, i): self._valid(i) return self.ls[self._newindex(i)] def __delitem__(self, i): self._valid(i) del self.ls[self._newindex(i)] def insert(self, i, x): self._valid(i) self.ls.insert(i+ self.beg, x) def __len__(self): return self.end - self.beg def __setitem__(self, i, x): self.ls[self._newindex(i)] = x def _valid(self, i): if isinstance(i, slice): self._valid(i.start) self._valid(i.stop) elif isinstance(i, int): if i<0 or i>=self.__len__(): raise IndexError() else: raise TypeError() def _newindex(self, i): if isinstance(i, slice): return slice(self.beg + i.start, self.beg + i.stop, i.step) else: return i + self.beg 

उदाहरण:

 >>> a = list(range(10)) >>> s = Sublist(a, 3, 8) >>> s[2:4] [5, 6] >>> s[2] = 15 >>> a [0, 1, 2, 3, 4, 15, 6, 7, 8, 9] 

आप संपादित कर सकते हैं : ऐसा कुछ करें

 shiftedlist = type('ShiftedList', (list,), {"__getitem__": lambda self, i: list.__getitem__(self, i + 3)} )([1, 2, 3, 4, 5, 6]) 

अनिवार्य रूप से एक-लाइनर होने पर, यह बहुत पायथनिक नहीं है, लेकिन यह मूल सार है।

संपादित करें: मुझे यह एहसास हुआ है कि यह काम नहीं करता क्योंकि list() अनिवार्य रूप से सूची पारित की एक उथले प्रतिलिपि करेगी। तो यह अंत में अधिक या कम हो जाएगा, जैसा कि सूची को टुकड़ा करना है। वास्तव में कम, __len__ लापता ओवरराइड के __len__ आपको एक प्रॉक्सी क्लास का उपयोग करना होगा; विवरण के लिए मिस्टर मार्टले के उत्तर देखें।

यदि आप "दृश्य" तक पहुंचने के लिए जा रहे हैं, तो आप केवल इसे इस्तेमाल कर सकते हैं। विलिस (..) आप अधिक जानकारी के लिए दस्तावेज देख सकते हैं ।

 l = [1, 2, 3, 4, 5] d = [1:3] #[2, 3] d = itertools.islice(2, 3) # iterator yielding -> 2, 3 

आप टुकड़ों में उन्हें बदलने के लिए व्यक्तिगत तत्वों तक नहीं पहुंच सकते हैं और यदि आप सूची को फिर से कॉल करें (..) को बदलना चाहते हैं।