2011-05-27 15 views
5

मैं ऐसे कोड है:अजगर, सूची के साथ काम करने comprehensions

a = [[1, 1], [2, 1], [3, 0]] 

मैं दो सूचियों प्राप्त करना चाहते हैं, पहले 'a', जहां a[][1] = 1 के तत्व शामिल हैं, और दूसरा - तत्वों जहां a[][1] = 0। तो

first_list = [[1, 1], [2, 1]] 

second_list = [[3, 0]]. 

मैं दो सूची समझ के साथ इस तरह बात कर सकते हैं:

first_list = [i for i in a if i[1] == 1] 

second_list = [i for i in a if i[1] == 0] 

लेकिन शायद अन्य (अधिक pythonic, या कम) तरीका यह है मौजूद है? आपके उत्तरों के लिए धन्यवाद।

उत्तर

7

सूची समझ बहुत पाइथोनिक और ऐसा करने का अनुशंसित तरीका है। आपका कोड ठीक है।

+0

सहमत:

फिर भी एक और विकल्प फिल्टर और नक्शे होगा। 2 अलग-अलग सूचियां/डेटा सेट हैं, इसलिए 2 अलग-अलग समझों का उपयोग किया जाना चाहिए। – Jordan

2

आप sorted() और itertools.groupby() का उपयोग करते हैं सकता है, लेकिन मैं नहीं जानता कि यह है कि यह pythonic से प्रति के रूप में योग्य होगा:

>>> dict((k, list(v)) for (k, v) in itertools.groupby(sorted(a, key=operator.itemgetter(1)), operator.itemgetter(1))) 
{0: [[3, 0]], 1: [[1, 1], [2, 1]]} 
+0

केवल समझ का उपयोग करने से अधिक जटिल लगता है? लेकिन मुझे itertoos के उपयोग से प्यार है तो +1 –

+0

अधिक जटिल, निश्चित रूप से। लेकिन डेटा के साथ आप जो चीजें करना चाहते हैं, उतनी तेजी से बढ़ जाती है, यह समाधान अपेक्षाकृत बोलता है। –

+0

बस एक साइड नोट के रूप में ऑपरेटर क्या है? –

3

आप एक पंक्ति आप कुछ कर सकते हैं में यह करना चाहते हैं

first_list, second_list = [i for i in a if i[1] == 1], [i for i in a if i[1] == 0] 

याद रखें कि, "स्पष्ट से स्पष्ट स्पष्ट है।"

आपका कोड ठीक

0

क्या इस बारे में है,

In [1]: a = [[1, 1], [2, 1], [3, 0]] 

In [2]: first_list = [] 

In [3]: second_list = [] 

In [4]: [first_list.append(i) if i[1] == 1 else second_list.append(i) for i in a] 
Out[4]: [None, None, None] 

In [5]: first_list, second_list 
Out[5]: ([[1, 1], [2, 1]], [[3, 0]]) 
बजाय

दो sublist, मैं dict (या defaultdict, OrderedDict, काउंटर, आदि)

In [6]: from collections import defaultdict 

In [7]: d = defaultdict(list) 

In [8]: [d[i[1]].append(i) for i in a] 
Out[8]: [None, None, None] 

In [9]: d 
Out[9]: {0: [[3, 0]], 1: [[1, 1], [2, 1]]} 
+1

साइड इफेक्ट्स के लिए सख्ती से सूची समझ का उपयोग एंटी-पायथनिक है। –

+0

@lgnacio, सहमत हैं, कभी-कभी यह सूची समझ के बिना शायद अधिक पठनीय हो सकता है (इसे लूप शैली के लिए कुछ के साथ बदलें) – sunqiang

0

तो पसंद करते हैं सूचियां काफी कम हैं तो दो सूची समझ ठीक हो जाएंगी: आपको प्रदर्शन के बारे में चिंतित नहीं होना चाहिए जब तक आपका कोड सभी काम नहीं कर रहा हो और आपको पता है कि यह बहुत धीमी है।

अपनी सूची लंबे होते हैं या कोड अक्सर और चलाता है आप दिखा दिया है कि यह एक टोंटी है तो तुम सब करने की है पाश के लिए सूची comprehensions से स्विच एक के लिए है:

first_list, second_list = [], [] 
for element in a: 
    if element[1] == 1: 
     first_list.append(element) 
    else: 
     second_list.append(element) 

है जो दोनों मामलों को स्पष्ट और आसानी से बढ़ाया गया।

0

सूची समझें बहुत अच्छी हैं। यदि आप थोड़ा अधिक सरल कोड चाहते हैं (लेकिन थोड़ा लंबा) तो बस लूप के लिए उपयोग करें।

a = [[1, 1], [2, 1], [3, 0]] 
g1=filter(lambda i: i[1]==1,a) 
g1=map(lambda i: i[0],g1) 
g2=filter(lambda i: i[1]==0,a) 
g2=map(lambda i: i[0],g2) 
print g1 
print g2 
संबंधित मुद्दे