समझ के आकार को सीमित कैसे करें?

Question

मेरे पास list है और एक और सूची (समझ के माध्यम से) बनाना चाहते हैं। मैं चाहूँगा इस नई सूची, आकार में सीमित करने के लिए किया जा एक शर्त के माध्यम से

निम्नलिखित कोड विफल हो जाएगा:

a = [1, 2, 1, 2, 1, 2] 
b = [i for i in a if i == 1 and len(b) < 3] 

साथ

Traceback (most recent call last): 
    File "compr.py", line 2, in <module> 
    b = [i for i in a if i == 1 and len(b) < 3] 
    File "compr.py", line 2, in <listcomp> 
    b = [i for i in a if i == 1 and len(b) < 3] 
NameError: name 'b' is not defined 

क्योंकि b पर अभी तक परिभाषित नहीं है समय समझ आ गई है।

क्या बिल्ड समय पर नई सूची के आकार को सीमित करने का कोई तरीका है?

नोट: मैं जब एक काउंटर तक पहुँच जाता है उचित break के साथ एक for लूप में समझ को तोड़ सकते थे, लेकिन मैं अगर वहाँ एक व्यवस्था है जिसके एक समझ का उपयोग करता है पता करने के लिए करना चाहते हैं।

Answer 1

आप एक जनरेटर अभिव्यक्ति का उपयोग छानने ऐसा करने के लिए, तो islice() उपयोग कर सकते हैं पुनरावृत्तियों की संख्या को सीमित करने के लिए:

from itertools import islice 

filtered = (i for i in a if i == 1) 
b = list(islice(filtered, 3)) 

यह सुनिश्चित करता है कि आप अधिक काम करना नहीं है की तुलना में आप उन 3 तत्वों का उत्पादन करने के लिए है ।

ध्यान दें कि यहां सूची समझ का उपयोग करने में अब कोई बिंदु नहीं है; एक सूची समझ को तोड़ा नहीं जा सकता है, आप अंत में पुनरावृत्त में बंद कर रहे हैं।

Answer 2

@Martijn Pieters पूरी तरह से सही है कि itertools.islice इसे हल करने का सबसे अच्छा तरीका है। हालांकि यदि आपको कोई अतिरिक्त (बाहरी) लाइब्रेरी नहीं है तो आप iteration_utilities का उपयोग कर सकते हैं जो इन itertools और उनके अनुप्रयोगों (और कुछ अतिरिक्त वाले) को बहुत से लपेटता है। यह इस थोड़ा आसान कम से कम अगर आप कार्यात्मक प्रोग्रामिंग की तरह बना सकते हैं,:

>>> from iteration_utilities import Iterable 

>>> Iterable([1, 2, 1, 2, 1, 2]).filter((1).__eq__)[:2].as_list() 
[1, 1] 

>>> (Iterable([1, 2, 1, 2, 1, 2]) 
...   .filter((1).__eq__) # like "if item == 1" 
...   [:2]     # like "islice(iterable, 2)" 
...   .as_list())   # like "list(iterable)" 
[1, 1] 

iteration_utilities.Iterable वर्ग जनरेटर का उपयोग करता है आंतरिक रूप से तो यह केवल प्रक्रिया आवश्यक के रूप में कई आइटम जब तक आप में से किसी को कॉल करेंगे as_* (या get_*) -methods।

---

^{अस्वीकरण: मैं the iteration_utilities library के लेखक हूँ।}

Answer 3

आप और itertools.count इस्तेमाल कर सकते हैं itertools.takewhile एक काउंटर उत्पन्न करने के लिए एक जनरेटर से अधिक बार-बार दोहराना को रोकने के लिए जब काउंटर वांछित पूर्णांक (3 इस मामले में) तक पहुँच जाता है:

from itertools import count, takewhile 
c = count() 
b = list(takewhile(lambda x: next(c) < 3, (i for i in a if i == 1))) 

या किसी ऐसे ही विचार एक निर्माण निर्माण जनरेटर को समाप्त करने के लिए StopIteration बढ़ाने के लिए।यही कारण है कि निकटतम आप breaking the list comprehension के अपने मूल विचार करने के लिए मिल जाएगा है, लेकिन मैं सबसे अच्छा अभ्यास के रूप में यह सिफारिश नहीं होगा:

c = count() 
b = list(i if next(c) < 3 else next(iter([])) for i in a if i == 1) 

उदाहरण:

>>> a = [1,2,1,4,1,1,1,1] 

>>> c = count() 
>>> list(takewhile(lambda x: next(c) < 3, (i for i in a if i == 1))) 
[1, 1, 1] 

>>> c = count() 
>>> list(i if next(c) < 3 else next(iter([])) for i in a if i == 1) 
[1, 1, 1] 

Answer 4

उपयोग की गणना:

b = [n for i,n in enumerate(a) if n==1 and i<3]