दिलचस्प पोस्ट
HTML स्थिर पृष्ठ में पेज लोड कैसे रोकें योजना में एक सूची में तत्व की घटना की गणना करें? IIS7 पर क्लासिक एएसपी: 500 आंतरिक सर्वर त्रुटि पर ब्राउज़र में त्रुटियों को भेजने से इनकार करते हुए PHP स्क्रिप्ट को समय-समय पर निष्पादित करने का सबसे अच्छा तरीका है? क्या मैं दो फाइलों की तुलना करने के लिए file_get_contents () का उपयोग कर सकता हूं? Std :: array को कैसे प्रारंभ करें <टी, एन> सुंदर ढंग से अगर टी डिफ़ॉल्ट रूप से निर्मित नहीं है? सीतनिद्रा में होना hbm2ddl.auto संभव मूल्यों और वे क्या करते हैं? इकाई ढांचे में शामिल होने छोड़ दिया 2038 से परे PHP में तिथियां एक्सेस करना Def foo = {} और def foo () = {} स्काला में अंतर क्या है? ओरेकल स्कीमा (स्क्रिप्ट) के संपूर्ण डीडीएल कैसे उत्पन्न करें? एक शून्य रिटर्निंग? जावास्क्रिप्ट में कोष्ठकों के बीच एक स्ट्रिंग पाने के लिए नियमित अभिव्यक्ति सी # आवेदन जीयूआई और कमांडलाइन दोनों जावास्क्रिप्ट गतिशील रूप से लोड करें

मुझे कैसे पता चलेगा कि कोई जनरेटर प्रारंभ से खाली है या नहीं?

क्या जनरेटर के पास कोई आइटम नहीं है, जैसे पीक, हैनक्सेंट, रिक्त है, उन पंक्तियों के साथ कुछ है?

Solutions Collecting From Web of "मुझे कैसे पता चलेगा कि कोई जनरेटर प्रारंभ से खाली है या नहीं?"

आपके प्रश्न का सरल उत्तर: नहीं, कोई आसान तरीका नहीं है वहाँ बहुत सारे काम-आस-पास हैं

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

आप एक has_next फ़ंक्शन लिख सकते हैं या यदि आप चाहें तो फैंसी डेकोरेटर के साथ एक विधि के रूप में यहां जनरेटर पर भी थप्पड़ मार सकते हैं

सुझाव:

 def peek(iterable): try: first = next(iterable) except StopIteration: return None return first, itertools.chain([first], iterable) 

उपयोग:

 res = peek(mysequence) if res is None: # sequence is empty. Do stuff. else: first, mysequence = res # Do something with first, maybe? # Then iterate over the sequence: for element in mysequence: # etc. 

एक सरल तरीका अगले पैरामीटर के लिए वैकल्पिक पैरामीटर का उपयोग करना है जो जनरेटर समाप्त होने पर (या रिक्त) उपयोग किया जाता है। उदाहरण के लिए:

 iterable = some_generator() _exhausted = object() if next(iterable, _exhausted) == _exhausted: print('generator is empty') 

संपादित करें: मेहेतुंगी की टिप्पणी में समस्या को ठीक किया।

मैं दूसरे समाधान की पेशकश करने से नफरत करता हूं, विशेष रूप से एक जो कि मैं स्वयं का उपयोग नहीं करता, लेकिन, अगर आपको पूरी तरह से ऐसा करना था और जनरेटर का उपभोग नहीं करना है, तो अन्य जवाबों के अनुसार:

 def do_something_with_item(item): print item empty_marker = object() try: first_item = my_generator.next() except StopIteration: print 'The generator was empty' first_item = empty_marker if first_item is not empty_marker: do_something_with_item(first_item) for item in my_generator: do_something_with_item(item) 

अब मुझे वास्तव में इस समाधान को पसंद नहीं है, क्योंकि मेरा मानना ​​है कि यह ऐसा नहीं है कि जनरेटर कैसे उपयोग किया जाए।

सबसे अच्छा तरीका, आईएमएचओ, एक विशेष परीक्षण से बचने के लिए होगा। अधिकांश समय, एक जनरेटर का उपयोग परीक्षण होता है:

 thing_generated = False # Nothing is lost here. if nothing is generated, # the for block is not executed. Often, that's the only check # you need to do. This can be done in the course of doing # the work you wanted to do anyway on the generated output. for thing in my_generator(): thing_generated = True do_work(thing) 

यदि यह पर्याप्त नहीं है, तो आप अभी भी एक स्पष्ट परीक्षण कर सकते हैं। इस बिंदु पर, thing में उत्पन्न अंतिम मान शामिल होगा। अगर कुछ भी उत्पन्न नहीं हुआ है, तो इसे अपरिभाषित किया जाएगा – जब तक कि आपने पहले ही चर को परिभाषित नहीं किया है आप thing के मूल्य की जांच कर सकते हैं, लेकिन यह थोड़ा अविश्वसनीय है इसके बजाय, बस ब्लॉक के भीतर एक झंडा निर्धारित करें और बाद में इसे जांचें:

 if not thing_generated: print "Avast, ye scurvy dog!" 

next(generator, None) is not None

या किसी को None बदल दें, लेकिन जो भी मूल्य आप जानते हैं वह आपके जनरेटर में नहीं है

संपादित करें : हां, यह जनरेटर में 1 आइटम छोड़ देगा। अक्सर, हालांकि, मैं जांचता हूं कि क्या जनरेटर केवल सत्यापन उद्देश्यों के लिए खाली है, फिर वास्तव में इसका उपयोग नहीं करें। या अन्यथा मैं ऐसा कुछ करता हूं:

 def foo(self): if next(self.my_generator(), None) is None: raise Exception("Not initiated") for x in self.my_generator(): ... 

स्पष्ट दृष्टिकोण के लिए क्षमा करें, लेकिन सबसे अच्छा तरीका करना होगा:

 for item in my_generator: print item 

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

यह आपके कोड के साथ बिल्कुल फिट नहीं हो सकता है, लेकिन जनरेटर के मुहावरे के लिए यही है: फिर से चलना, तो शायद आप थोड़ा अपना दृष्टिकोण बदल सकते हैं या जनरेटर का उपयोग नहीं कर सकते।

मुझे एहसास है कि इस बिंदु पर यह पोस्ट 5 साल पुराना है, लेकिन मुझे ऐसा करने के एक मुहावरे के तरीके की तलाश करते हुए पाया, और मेरा समाधान पोस्ट नहीं हुआ। तो भावी पीढ़ी के लिए:

 import itertools def get_generator(): """ Returns (bool, generator) where bool is true iff the generator is not empty. """ gen = (i for i in [0, 1, 2, 3, 4]) a, b = itertools.tee(gen) try: a.next() except StopIteration: return (False, b) return (True, b) 

बेशक, जैसा कि मुझे यकीन है कि कई टिप्पणीकारों का कहना होगा, यह हैक है और केवल कुछ सीमित स्थितियों में काम करता है (उदाहरण के लिए जनरेटर साइड इफेक्ट फ्री हैं)। YMMV।

जनरेटर रिक्त है यह देखने के लिए आपको यह करना है कि अगले परिणाम प्राप्त करने का प्रयास करना है। बेशक, यदि आप उस परिणाम का उपयोग करने के लिए तैयार नहीं हैं तो आपको इसे फिर से वापस करने के लिए इसे संग्रहित करना होगा।

यहाँ एक आवरण वर्ग है जो एक __nonzero__ परीक्षा को जोड़ने के लिए एक मौजूदा इटरेटर में जोड़ा जा सकता है, ताकि आप देख सकें कि क्या जनरेटर सरल है if । यह शायद एक डेकोरेटर में भी बदल सकता है

 class GenWrapper: def __init__(self, iter): self.source = iter self.stored = False def __iter__(self): return self def __nonzero__(self): if self.stored: return True try: self.value = self.source.next() self.stored = True except StopIteration: return False return True def next(self): if self.stored: self.stored = False return self.value return self.source.next() 

यहां बताया गया है कि आप इसका उपयोग कैसे करेंगे:

 with open(filename, 'r') as f: f = GenWrapper(f) if f: print 'Not empty' else: print 'Empty' 
 >>> gen = (i for i in []) >>> next(gen) Traceback (most recent call last): File "<pyshell#43>", line 1, in <module> next(gen) StopIteration 

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

एक और बात जो आप कर सकते हैं:

 >>> gen = (i for i in []) >>> if not list(gen): print('empty generator') 

यदि आपको जनरेटर का इस्तेमाल करने से पहले जानने की जरूरत है, तो नहीं, कोई आसान तरीका नहीं है। यदि आप जनरेटर का उपयोग करने के बाद तक इंतजार कर सकते हैं, तो एक सरल तरीका है:

 was_empty = True for some_item in some_generator: was_empty = False do_something_with(some_item) if was_empty: handle_already_empty_generator_case() 

यह मेरा आसान तरीका है कि मैं एक इटोरेटर लौटने के लिए उपयोग करते हुए जांच करता हूं कि क्या कुछ पाई गई थी मैं सिर्फ जांचता हूं कि क्या लूप चलाता है:

  n = 0 for key, value in iterator: n+=1 yield key, value if n == 0: print ("nothing found in iterator) break 

यहां एक साधारण डेकोरेटर है जो जनरेटर को लपेटता है, इसलिए यह कोई भी रिक्त नहीं देता है। यह उपयोगी हो सकता है यदि आपके कोड को यह जानना आवश्यक है कि जनरेटर इसके माध्यम से पाशन करने से पहले कुछ भी उत्पन्न करेगा या नहीं।

 def generator_or_none(func): """Wrap a generator function, returning None if it's empty. """ def inner(*args, **kwargs): # peek at the first item; return None if it doesn't exist try: next(func(*args, **kwargs)) except StopIteration: return None # return original generator otherwise first item will be missing return func(*args, **kwargs) return inner 

उपयोग:

 import random @generator_or_none def random_length_generator(): for i in range(random.randint(0, 10)): yield i gen = random_length_generator() if gen is None: print('Generator is empty') 

एक उदाहरण जहां यह उपयोगी होता है टेम्पलेटिंग कोड में है – अर्थात जीनजा 2

 {% if content_generator %} <section> <h4>Section title</h4> {% for item in content_generator %} {{ item }} {% endfor % </section> {% endif %} 

बस itertools.chain के साथ जनरेटर लपेटो, कुछ है जो दूसरे iterable के रूप में iterable के अंत का प्रतिनिधित्व करेंगे, तो बस उस के लिए जाँच करें।

उदाहरण के लिए:

 import itertools g = some_iterable eog = object() wrap_g = itertools.chain(g, [eog]) 

अब जो भी छोड़ा गया है, उस मूल्य की जांच करना है जो हम इसे चालू होने के अंत में जोड़ते हैं, जब आप इसे पढ़ते हैं तो यह अंत का मतलब होगा

 for value in wrap_g: if value == eog: # DING DING! We just found the last element of the iterable pass # Do something 

इस्तालिस का उपयोग करते हुए आपको यह पता चलता है कि यह रिक्त है या नहीं, केवल पहली यात्रा की जांच करें।

इटरेटोल्स से आयात करें इस्तालिस

def isempty (इटरेबल):
वापसी की सूची (आईएसएलआईसीई (दोबारा, 1)) == []

मेरे मामले में मुझे यह जानना जरूरी था कि यदि एक फ़ंक्शन को पास करने से पहले जनरेटरों का एक होस्ट आबादी हो गया था, जिसने आइटम्स को विलय कर दिया, अर्थात, zip(...) समाधान इसी तरह के है, लेकिन स्वीकार्य जवाब से काफी अलग है:

परिभाषा:

 def has_items(iterable): try: return True, itertools.chain([next(iterable)], iterable) except StopIteration: return False, [] 

उपयोग:

 def filter_empty(iterables): for iterable in iterables: itr_has_items, iterable = has_items(iterable) if itr_has_items: yield iterable def merge_iterables(iterables): populated_iterables = filter_empty(iterables) for items in zip(*populated_iterables): # Use items for each "slice" 

मेरी विशेष समस्या के पास संपत्ति है जो इटेरेबल्स या तो खाली हैं या बिल्कुल उसी प्रविष्टियों की संख्या है

किसी भी () का उपयोग करने के बारे में क्या? मैं इसे जनरेटर के साथ प्रयोग करता हूँ और यह ठीक काम कर रहा है यहां इस बात के बारे में कुछ बताते हुए आदमी है

मैं इसे योग समारोह का उपयोग करके हल किया नीचे glob.iglob (जो जनरेटर देता है) के साथ मैं एक उदाहरण के लिए नीचे देखें

 def isEmpty(): files = glob.iglob(search) if sum(1 for _ in files): return True return False 

* यह शायद बड़ी जेनरेटर के लिए काम नहीं करेगा लेकिन छोटे सूचियों के लिए अच्छी तरह से प्रदर्शन करना चाहिए