मेरे पास एक जनरेटर ऑब्जेक्ट है जो कई उपज द्वारा लौटाया गया है। इस जनरेटर को कॉल करने की तैयारी बल्कि समय लेने वाली कार्रवाई है। यही कारण है कि मैं कई बार जनरेटर का पुन: उपयोग करना चाहता हूं।
y = FunctionWithYield()
for x in y: print(x)
#here must be something to reset 'y'
for x in y: print(x)
बेशक, मैं सामग्री को सरल सूची में कॉपी करने का ध्यान रख रहा हूं। क्या मेरा जनरेटर रीसेट करने का कोई तरीका है?
जवाबों:
एक अन्य विकल्प itertools.tee()अपने जनरेटर का दूसरा संस्करण बनाने के लिए फ़ंक्शन का उपयोग करना है :
y = FunctionWithYield()
y, y_backup = tee(y)
for x in y:
print(x)
for x in y_backup:
print(x)
यह मेमोरी उपयोग के दृष्टिकोण से फायदेमंद हो सकता है यदि मूल पुनरावृत्ति सभी वस्तुओं को संसाधित नहीं कर सकता है।
जनरेटर फिर से जारी नहीं किए जा सकते। आपके पास निम्नलिखित विकल्प हैं:
जेनरेटर फ़ंक्शन को फिर से चलाएँ, पीढ़ी को पुनरारंभ करना:
y = FunctionWithYield()
for x in y: print(x)
y = FunctionWithYield()
for x in y: print(x)
मेमोरी या डिस्क पर एक डेटा संरचना में जनरेटर परिणामों को स्टोर करें जिसे आप फिर से पुन: व्यवस्थित कर सकते हैं:
y = list(FunctionWithYield())
for x in y: print(x)
# can iterate again:
for x in y: print(x)
विकल्प 1 का नकारात्मक पक्ष यह है कि यह फिर से मूल्यों की गणना करता है। यदि वह सीपीयू-गहन है तो आप दो बार गणना करते हैं। दूसरी ओर, 2 का नकारात्मक हिस्सा भंडारण है। मूल्यों की पूरी सूची स्मृति पर संग्रहीत की जाएगी। यदि बहुत अधिक मूल्य हैं, तो यह अव्यावहारिक हो सकता है।
तो आपके पास क्लासिक मेमोरी बनाम प्रोसेसिंग ट्रेडऑफ है । मैं मानों को संचय किए बिना या उन्हें फिर से गणना किए बिना जनरेटर को रिवाइंड करने के तरीके की कल्पना नहीं कर सकता।
संभवतः सबसे सरल उपाय यह है कि किसी वस्तु में महंगे हिस्से को लपेटकर जनरेटर को पास किया जाए:
data = ExpensiveSetup()
for x in FunctionWithYield(data): pass
for x in FunctionWithYield(data): pass
इस तरह, आप महंगी गणनाओं को कैश कर सकते हैं।
यदि आप एक ही समय में सभी परिणाम रैम में रख सकते हैं, तो list()एक सादे सूची में जनरेटर के परिणामों को उत्प्रेरित करने के लिए उपयोग करें और उसी के साथ काम करें।
मैं एक पुरानी समस्या का एक अलग समाधान पेश करना चाहता हूं
class IterableAdapter:
def __init__(self, iterator_factory):
self.iterator_factory = iterator_factory
def __iter__(self):
return self.iterator_factory()
squares = IterableAdapter(lambda: (x * x for x in range(5)))
for x in squares: print(x)
for x in squares: print(x)
इसका लाभ जब किसी चीज की तुलना में यह list(iterator)है कि यह O(1)अंतरिक्ष जटिलता है और list(iterator)है O(n)। नुकसान यह है कि, यदि आपके पास केवल इट्रेटर तक पहुंच है, लेकिन फ़ंक्शन जो इट्रेटर का उत्पादन नहीं करता है, तो आप इस पद्धति का उपयोग नहीं कर सकते। उदाहरण के लिए, ऐसा करना उचित प्रतीत हो सकता है, लेकिन यह काम नहीं करेगा।
g = (x * x for x in range(5))
squares = IterableAdapter(lambda: g)
for x in squares: print(x)
for x in squares: print(x)
यदि ग्रेज़गोरोज़ल्डकी का जवाब पर्याप्त नहीं होगा, तो आप शायद send()अपने लक्ष्य को पूरा करने के लिए उपयोग कर सकते हैं । संवर्धित जनरेटर और उपज अभिव्यक्तियों के बारे में अधिक जानकारी के लिए PEP-0342 देखें ।
अद्यतन: भी देखें itertools.tee()। इसमें ऊपर वर्णित कुछ मेमोरी बनाम प्रोसेसिंग ट्रेडऑफ शामिल हैं, लेकिन यह जनरेटर मेमोरी को ए में संग्रहीत करने से अधिक कुछ मेमोरी को बचा सकता है list; यह इस बात पर निर्भर करता है कि आप जनरेटर का उपयोग कैसे कर रहे हैं।
यदि आपका जनरेटर इस मायने में शुद्ध है कि इसका आउटपुट केवल उत्तीर्ण तर्कों और चरण संख्या पर निर्भर करता है, और आप चाहते हैं कि परिणामी जनरेटर पुनः आरंभ करने योग्य हो, तो यहां एक प्रकार का स्निपेट हो सकता है जो उपयोगी हो सकता है:
import copy
def generator(i):
yield from range(i)
g = generator(10)
print(list(g))
print(list(g))
class GeneratorRestartHandler(object):
def __init__(self, gen_func, argv, kwargv):
self.gen_func = gen_func
self.argv = copy.copy(argv)
self.kwargv = copy.copy(kwargv)
self.local_copy = iter(self)
def __iter__(self):
return self.gen_func(*self.argv, **self.kwargv)
def __next__(self):
return next(self.local_copy)
def restartable(g_func: callable) -> callable:
def tmp(*argv, **kwargv):
return GeneratorRestartHandler(g_func, argv, kwargv)
return tmp
@restartable
def generator2(i):
yield from range(i)
g = generator2(10)
print(next(g))
print(list(g))
print(list(g))
print(next(g))आउटपुट:
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[]
0
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
1सामान्य तौर पर, यदि एक पुनरावृत्तिकर्ता किसी अन्य पुनरावृत्ति शुरू होने से पहले डेटा का सबसे या सभी का उपयोग करता है, तो यह टी () के बजाय सूची () का उपयोग करने के लिए तेज़ है।
इसलिए list(iterable)आपके मामले में इसके बजाय इसका उपयोग करना सबसे अच्छा है ।
list()पूरे पुनरावृत्ति को स्मृति में रखता है
tee()अगर एक पुनरावृत्तिकर्ता सभी मानों का उपभोग करता है - तो यह है कि कैसे teeकाम करता है।
StopIterationआप अपने जेनरेटर-जनरेट करने वाले फ़ंक्शन को एक साधारण आवरण फ़ंक्शन लिख सकते हैं जो जनरेटर के समाप्त होने पर ट्रैक करता है। StopIterationजब यह पुनरावृत्ति के अंत तक पहुँच जाता है तो यह एक जनरेटर थ्रो का उपयोग करके ऐसा करेगा ।
import types
def generator_wrapper(function=None, **kwargs):
assert function is not None, "Please supply a function"
def inner_func(function=function, **kwargs):
generator = function(**kwargs)
assert isinstance(generator, types.GeneratorType), "Invalid function"
try:
yield next(generator)
except StopIteration:
generator = function(**kwargs)
yield next(generator)
return inner_funcजैसा कि आप ऊपर रख सकते हैं, जब हमारा आवरण फ़ंक्शन StopIterationअपवाद को पकड़ता है, तो यह केवल जनरेटर ऑब्जेक्ट को फिर से इनिशियलाइज़ करता है (फ़ंक्शन कॉल के किसी अन्य उदाहरण का उपयोग करके)।
और फिर, मान लें कि आप अपने जनरेटर-सप्लाई फ़ंक्शन को नीचे के रूप में परिभाषित करते हैं, तो आप इसे निहित करने के लिए पायथन फ़ंक्शन डेकोरेटर सिंटैक्स का उपयोग कर सकते हैं:
@generator_wrapper
def generator_generating_function(**kwargs):
for item in ["a value", "another value"]
yield itemआप एक फ़ंक्शन को परिभाषित कर सकते हैं जो आपके जनरेटर को लौटाता है
def f():
def FunctionWithYield(generator_args):
code here...
return FunctionWithYieldअब आप जितनी बार चाहें उतनी बार कर सकते हैं:
for x in f()(generator_args): print(x)
for x in f()(generator_args): print(x)मुझे यकीन नहीं है कि महंगी तैयारी से आपका क्या मतलब है, लेकिन मुझे लगता है कि आपके पास वास्तव में है
data = ... # Expensive computation
y = FunctionWithYield(data)
for x in y: print(x)
#here must be something to reset 'y'
# this is expensive - data = ... # Expensive computation
# y = FunctionWithYield(data)
for x in y: print(x)यदि ऐसा है, तो पुन: उपयोग क्यों नहीं किया जाता है data?
पुनरावृत्तियों को रीसेट करने का कोई विकल्प नहीं है। Iterator आमतौर पर जब यह next()कार्य के माध्यम से पुनरावृत्ति करता है तो बाहर निकलता है। केवल तरीका यह है कि पुनरावृति ऑब्जेक्ट पर पुनरावृति से पहले बैकअप लेना है। नीचे देखें।
आइटम 0 से 9 के साथ पुनरावृत्त वस्तु बनाना
i=iter(range(10))अगले () फ़ंक्शन के माध्यम से Iterating जो बाहर पॉप जाएगा
print(next(i))सूची में पुनरावृत्त वस्तु को परिवर्तित करना
L=list(i)
print(L)
output: [1, 2, 3, 4, 5, 6, 7, 8, 9]इसलिए आइटम 0 पहले से ही पॉप आउट है। साथ ही सभी आइटम पॉप-अप हो गए हैं क्योंकि हमने सूची में पुनरावृत्ति को परिवर्तित कर दिया है।
next(L)
Traceback (most recent call last):
File "<pyshell#129>", line 1, in <module>
next(L)
StopIterationतो आपको पुनरावृति शुरू करने से पहले बैकअप के लिए पुनरावृत्तियों को सूचियों में बदलना होगा। सूची को पुनरावृत्त में परिवर्तित किया जा सकता हैiter(<list-object>)
अब आप more_itertools.seekable(तृतीय-पक्ष उपकरण) का उपयोग कर सकते हैं जो पुनरावृत्तियों को रीसेट करने में सक्षम बनाता है।
के माध्यम से स्थापित करें > pip install more_itertools
import more_itertools as mit
y = mit.seekable(FunctionWithYield())
for x in y:
print(x)
y.seek(0) # reset iterator
for x in y:
print(x)ध्यान दें: मेमोरी की खपत इट्रेटर को आगे बढ़ाते हुए बढ़ती है, इसलिए बड़े पुनरावृत्तियों से सावधान रहें।
आप ऐसा कर सकते हैं कि itertools.cycle () का उपयोग करके आप इस विधि के साथ एक इटरेटर बना सकते हैं और फिर इटरेटर पर एक लूप के लिए निष्पादित कर सकते हैं जो इसके मूल्यों पर लूप करेगा।
उदाहरण के लिए:
def generator():
for j in cycle([i for i in range(5)]):
yield j
gen = generator()
for i in range(20):
print(next(gen))बार-बार 20 नंबर, 0 से 4 उत्पन्न करेगा।
डॉक्स से एक नोट:
Note, this member of the toolkit may require significant auxiliary storage (depending on the length of the iterable).ठीक है, आप कहते हैं कि आप एक जनरेटर को कई बार कॉल करना चाहते हैं, लेकिन आरंभीकरण महंगा है ... ऐसा कुछ क्या है?
class InitializedFunctionWithYield(object):
def __init__(self):
# do expensive initialization
self.start = 5
def __call__(self, *args, **kwargs):
# do cheap iteration
for i in xrange(5):
yield self.start + i
y = InitializedFunctionWithYield()
for x in y():
print x
for x in y():
print xवैकल्पिक रूप से, आप बस अपना स्वयं का वर्ग बना सकते हैं जो इट्रेटर प्रोटोकॉल का अनुसरण करता है और कुछ प्रकार के 'रीसेट' फ़ंक्शन को परिभाषित करता है।
class MyIterator(object):
def __init__(self):
self.reset()
def reset(self):
self.i = 5
def __iter__(self):
return self
def next(self):
i = self.i
if i > 0:
self.i -= 1
return i
else:
raise StopIteration()
my_iterator = MyIterator()
for x in my_iterator:
print x
print 'resetting...'
my_iterator.reset()
for x in my_iterator:
print xhttps://docs.python.org/2/library/stdtypes.html#iterator-types http://anandology.com/python-ults-book/iterators.html
__call__
मेरा उत्तर थोड़ा अलग समस्या हल करता है: यदि जनरेटर को आरंभीकरण करना महंगा है और प्रत्येक उत्पन्न वस्तु को उत्पन्न करना महंगा है। लेकिन हमें कई कार्यों में कई बार जनरेटर का उपभोग करने की आवश्यकता होती है। जनरेटर और प्रत्येक उत्पन्न वस्तु को ठीक से कॉल करने के लिए एक बार हम थ्रेड्स का उपयोग कर सकते हैं और प्रत्येक उपभोग के तरीकों को अलग-अलग धागे में चला सकते हैं। हम जीआईएल के कारण सही समानता हासिल नहीं कर सकते हैं, लेकिन हम अपने लक्ष्य को प्राप्त करेंगे।
इस दृष्टिकोण ने निम्नलिखित मामले में अच्छा काम किया: गहन शिक्षण मॉडल बहुत सारी छवियों को संसाधित करता है। परिणाम छवि पर बहुत सारी वस्तुओं के लिए बहुत सारे मुखौटे हैं। प्रत्येक मुखौटा स्मृति का उपभोग करता है। हमारे पास लगभग 10 विधियां हैं जो अलग-अलग आंकड़े और मीट्रिक बनाती हैं, लेकिन वे एक ही बार में सभी छवियां लेती हैं। सभी चित्र स्मृति में फिट नहीं हो सकते। Moethods आसानी से पुनरावृत्ति को स्वीकार करने के लिए फिर से लिखा जा सकता है।
class GeneratorSplitter:
'''
Split a generator object into multiple generators which will be sincronised. Each call to each of the sub generators will cause only one call in the input generator. This way multiple methods on threads can iterate the input generator , and the generator will cycled only once.
'''
def __init__(self, gen):
self.gen = gen
self.consumers: List[GeneratorSplitter.InnerGen] = []
self.thread: threading.Thread = None
self.value = None
self.finished = False
self.exception = None
def GetConsumer(self):
# Returns a generator object.
cons = self.InnerGen(self)
self.consumers.append(cons)
return cons
def _Work(self):
try:
for d in self.gen:
for cons in self.consumers:
cons.consumed.wait()
cons.consumed.clear()
self.value = d
for cons in self.consumers:
cons.readyToRead.set()
for cons in self.consumers:
cons.consumed.wait()
self.finished = True
for cons in self.consumers:
cons.readyToRead.set()
except Exception as ex:
self.exception = ex
for cons in self.consumers:
cons.readyToRead.set()
def Start(self):
self.thread = threading.Thread(target=self._Work)
self.thread.start()
class InnerGen:
def __init__(self, parent: "GeneratorSplitter"):
self.parent: "GeneratorSplitter" = parent
self.readyToRead: threading.Event = threading.Event()
self.consumed: threading.Event = threading.Event()
self.consumed.set()
def __iter__(self):
return self
def __next__(self):
self.readyToRead.wait()
self.readyToRead.clear()
if self.parent.finished:
raise StopIteration()
if self.parent.exception:
raise self.parent.exception
val = self.parent.value
self.consumed.set()
return valUssage:
genSplitter = GeneratorSplitter(expensiveGenerator)
metrics={}
executor = ThreadPoolExecutor(max_workers=3)
f1 = executor.submit(mean,genSplitter.GetConsumer())
f2 = executor.submit(max,genSplitter.GetConsumer())
f3 = executor.submit(someFancyMetric,genSplitter.GetConsumer())
genSplitter.Start()
metrics.update(f1.result())
metrics.update(f2.result())
metrics.update(f3.result())itertools.isliceया async के लिए aiostream.stream.take, और यह पोस्ट आपको asyn /
यह कोड ऑब्जेक्ट द्वारा किया जा सकता है। यहाँ उदाहरण है।
code_str="y=(a for a in [1,2,3,4])"
code1=compile(code_str,'<string>','single')
exec(code1)
for i in y: print i1 2 3 4
for i in y: print i
exec(code1)
for i in y: print i1 2 3 4
execकि इस तरह के सरल मामले के लिए थोड़ा गैर-अनुशंसित।
y = list(y)अपने शेष कोड के साथ अपरिवर्तित उपयोग कर सकते हैं।