क्या पाइथन में मनमाने ढंग से बड़ी स्ट्रिंग को संभालना संभव है? (* ऑपरेटर के माध्यम से बनाया)

Question

हम * ऑपरेटर के साथ निश्चित संरचना लेकिन मनमाना लंबाई के तार का निर्माण कर सकते निम्नलिखित के साथ:

length = 10 
print "0" * length 

यह रिटर्न क्या उम्मीद है, 0000000000। समस्या पैदा होती है जब लंबाई, जरूरत से ज्यादा बड़ी है एक अतिप्रवाह त्रुटि में परिणाम:

length = 10000000000000000000000000000000000000000000000 
print "0" * length 

यह OverflowError: cannot fit 'long' into an index-sized integer का परिणाम है।

मैं उत्सुक हूं, क्या इस तरह के एक फार्मूले को मनमाने ढंग से लंबाई के आकार के लिए इस्तेमाल किया जा सकता है? या परिदृश्य को संभालने का सही तरीका क्या है जहां length अज्ञात है और इस तरह का एक बड़ा मूल्य ले सकता है?

Answer 1

नहीं, आप में किसी भी प्रोग्रामिंग भाषा में अपने उदाहरण में बड़े स्ट्रिंग्स नहीं बना सकते हैं। स्ट्रिंग्स में प्रत्येक चरित्र होता है। और 10 बाइट्स किसी भी स्टोर की तुलना में अधिक डेटा की संभावना अधिक है। आप एक ट्रिलियन Google डेटासेंटर पर जा सकते हैं (मानते हैं कि Google के पास 1 वाईबी स्टोरेज है जो निश्चित रूप से अभी तक मामला नहीं है ..) और अभी भी बहुत कम डिस्क स्पेस है, अकेले रैम दें जो आपको चाहिए ऐसी स्ट्रिंग के लिए।

अपने उदाहरण से एक की तरह एक बड़ी स्ट्रिंग को स्टोर करने के लिए आपको अपना खुद का str बनाना होगा-जैसे वर्ग __mul__ को ऐसे तरीके से संभालता है जहां पुनरावृत्ति की संख्या वास्तव में स्मृति में पूरी स्ट्रिंग को संग्रहीत किए बिना संग्रहीत की जाती है। जाहिर है, जैसे ही आप उस स्ट्रिंग में संशोधन की अनुमति देते हैं, यह कार्यान्वयन बेहद जटिल हो जाएगा।

Answer 2

आप अजगर में स्ट्रिंग जेनरेटर की तरह कुछ लिख सकते हैं। उदाहरण के लिए:

import sys 

def stringWithArbitraryLength(stringLength): 
    n = 0 
    while n < stringLength: 
     # pattern here 
     if n % 2 == 0: 
      yield "0" 
     else: 
      yield "1" 
     n += 1 

Infinity = float('inf') 

# Usage 1: print the long string 
# for c in stringWithArbitraryLength(Infinity): 
# sys.stdout.write(c) 

# Usage 2: instantiate the long string 
soLong = stringWithArbitraryLength(100000) # output 01010101.... 
print ''.join(soLong) 

# Usage 3: transform the long string 
def transformString(longLongString): 
    for c in longLongString: 
     if c == "1": 
      yield "X" 
     else: 
      yield c 
soLong2 = stringWithArbitraryLength(100000) # output 0X0X0X0X.... 
print ''.join(transformString(soLong2)) 

यह कई सीमाएँ हैं:

1. यह केवल अनुक्रमिक अभिगम, नहीं यादृच्छिक अभिगम की अनुमति देता है। तो आपको स्ट्रिंग के माध्यम से चलने के लिए फॉर-लूप का उपयोग करना होगा।
2. प्रत्येक चरित्र बड़े सूचकांक वाले पात्रों पर निर्भर नहीं हो सकता है।
3. लम्बाई बड़ी है तो इंस्टेंटेशन मुश्किल है। लेकिन आप तत्काल के बाद यादृच्छिक पहुंच कर सकते हैं।

कई मामलों में, आपको पूरी स्ट्रिंग को तुरंत चालू करने की आवश्यकता नहीं है। क्योंकि आप इनपुट/आउटपुट करने के लिए आईओ स्ट्रीम का उपयोग कर सकते हैं। और स्ट्रिंग को संसाधित करने के लिए जनरेटर का उपयोग करें। तो हर बार जब आप केवल डेटा का हिस्सा संभालेंगे।

यदि आप लंबे, या असीमित लंबे, स्ट्रिंग के बारे में और अधिक समझना चाहते हैं, तो आप कुछ गैर-सख्त कार्यात्मक भाषाओं को सीख सकते हैं, उदाहरण के लिए, हास्केल। यह आलसी अभिव्यक्ति का मूल्यांकन करता है। इन भाषाओं में अनंतता सूची/स्ट्रिंग का अक्सर उपयोग किया जाता है।