संदर्भ द्वारा अपरिवर्तनीय तारों के स्लाइस और

Question

कॉपी न करें यदि आप पाइथन स्ट्रिंग पर string.split() का उपयोग करते हैं, तो यह तारों की एक सूची देता है। ये सबस्ट्रिंग जो विभाजित हो चुके हैं वे पैरेंट स्ट्रिंग के अपने हिस्से की प्रतियां हैं।

क्या इसके बजाय कुछ सस्ता स्लाइस ऑब्जेक्ट प्राप्त करना संभव है जिसमें केवल एक संदर्भ, ऑफसेट और बिट्स को विभाजित करने के लिए लंबाई हो?

और क्या इन उप-तारों को निकालने और उनका इलाज करने के लिए कुछ 'स्ट्रिंग व्यू' होना संभव है जैसे कि वे अपने बाइट्स की एक प्रति बनाये बिना तार हैं?

(जैसा कि मैंने बहुत बड़ी तार है मैं पूछता हूँ मैं काट करना चाहते हैं और कभी-कभी स्मृति से बाहर चल रहा हूँ;। प्रतियां को हटाने के एक सस्ते प्रोफ़ाइल निर्देशित जीत होगा)

Answer 1

buffer आप रीड-ओनली दे देंगे एक स्ट्रिंग पर देखें।

>>> s = 'abcdefghijklmnopqrstuvwxyz' 
>>> b = buffer(s, 2, 10) 
>>> b 
<read-only buffer for 0x7f935ee75d70, size 10, offset 2 at 0x7f935ee5a8f0> 
>>> b[:] 
'cdefghijkl' 

Answer 2

यहां त्वरित स्ट्रिंग-जैसे बफर रैपर है जिसके साथ आया था; मैं स्ट्रिंग का उपभोग करने के लिए अपेक्षित कोड को बदलने के बिना क्लासिक तारों के स्थान पर इसका उपयोग करने में सक्षम था।

class StringView: 
    def __init__(self,s,start=0,size=sys.maxint): 
     self.s, self.start, self.stop = s, start, min(start+size,len(s)) 
     self.size = self.stop - self.start 
     self._buf = buffer(s,start,self.size) 
    def find(self,sub,start=0,stop=None): 
     assert start >= 0, start 
     assert (stop is None) or (stop <= self.size), stop 
     ofs = self.s.find(sub,self.start+start,self.stop if (stop is None) else (self.start+stop)) 
     if ofs != -1: ofs -= self.start 
     return ofs 
    def split(self,sep=None,maxsplit=sys.maxint): 
     assert maxsplit > 0, maxsplit 
     ret = [] 
     if sep is None: #whitespace logic 
      pos = [self.start,self.start] # start and stop 
      def eat(whitespace=False): 
       while (pos[1] < self.stop) and (whitespace == (ord(self.s[pos[1]])<=32)): 
        pos[1] += 1 
      def eat_whitespace(): 
       eat(True) 
       pos[0] = pos[1] 
      eat_whitespace() 
      while pos[1] < self.stop: 
       eat() 
       ret.append(self.__class__(self.s,pos[0],pos[1]-pos[0])) 
       eat_whitespace() 
       if len(ret) == maxsplit: 
        ret.append(self.__class__(self.s,pos[1])) 
        break 
     else: 
      start = stop = 0 
      while len(ret) < maxsplit: 
       stop = self.find(sep,start) 
       if -1 == stop: 
        break 
       ret.append(self.__class__(self.s,self.start+start,stop-start)) 
       start = stop + len(sep) 
      ret.append(self.__class__(self.s,self.start+start,self.size-start)) 
     return ret 
    def split_str(self,sep=None,maxsplit=sys.maxint): 
     "if you really want strings and not views" 
     return [str(sub) for sub in self.split(sep,maxsplit)] 
    def __cmp__(self,s): 
     if isinstance(s,self.__class__): 
      return cmp(self._buf,s._buf) 
     assert isinstance(s,str), type(s) 
     return cmp(self._buf,s) 
    def __len__(self): 
     return self.size 
    def __str__(self): 
     return str(self._buf) 
    def __repr__(self): 
     return "'%s'"%self._buf 

if __name__=="__main__": 
    test_str = " this: is: a: te:st str:ing :" 
    test = Envelope.StringView(test_str) 
    print "find('is')" 
    print "\t",test_str.find("is") 
    print "\t",test.find("is") 
    print "find('is',4):" 
    print "\t",test_str.find("is",4) 
    print "\t",test.find("is",4) 
    print "find('is',4,7):" 
    print "\t",test_str.find("is",4,7) 
    print "\t",test.find("is",4,7) 
    print "split():" 
    print "\t",test_str.split() 
    print "\t",test.split() 
    print "split(None,2):" 
    print "\t",test_str.split(None,2) 
    print "\t",test.split(None,2) 
    print "split(':'):" 
    print "\t",test_str.split(":") 
    print "\t",test.split(":") 
    print "split('x'):" 
    print "\t",test_str.split("x") 
    print "\t",test.split("x") 
    print "''.split('x'):" 
    print "\t","".split("x") 
    print "\t",Envelope.StringView("").split("x") 

Answer 3

स्ट्रिंग ऑब्जेक्ट्स हमेशा पायथन में एक एनयूएल-समाप्त बफर को इंगित करते हैं, इसलिए सबस्ट्रिंग की प्रतिलिपि बनाई जानी चाहिए। जैसा कि इग्नासिओ ने इंगित किया है, आप स्ट्रिंग मेमोरी पर केवल पढ़ने के लिए दृश्य प्राप्त करने के लिए buffer() का उपयोग कर सकते हैं। buffer() बिल्ट-इन फ़ंक्शन को अधिक बहुमुखी memoryview ऑब्जेक्ट्स द्वारा अधिलेखित किया गया है, हालांकि, जो पाइथन 2.7 और 3.x (buffer() में पाइथन 3.x में उपलब्ध है) में उपलब्ध हैं।

s = "abcd" * 50 
view = memoryview(s) 
subview = view[10:20] 
print subview.tobytes() 

इस कोड को प्रिंट

cdabcdabcd 

जैसे ही आप tobytes() फोन, स्ट्रिंग की एक प्रतिलिपि बनाया जाएगा, लेकिन एक ही होता है जब इग्नेसियो के जवाब में ही पुराना buffer वस्तुओं टुकड़ा करने की क्रिया।