एक नेस्टेड सूची पर समझ की सूची?

Question

मेरे पास यह नेस्टेड सूची है:

l = [['40', '20', '10', '30'], ['20', '20', '20', '20', '20', '30', '20'], ['30', '20', '30', '50', '10', '30', '20', '20', '20'], ['100', '100'], ['100', '100', '100', '100', '100'], ['100', '100', '100', '100']]

अब, मैं जो करना चाहता हूं वह सूची में प्रत्येक तत्व को फ्लोट में परिवर्तित करना है। मेरा समाधान यह है:

newList = []
for x in l:
  for y in x:
    newList.append(float(y))

लेकिन क्या यह नेस्टेड सूची समझ का उपयोग करके किया जा सकता है, है ना?

मैंने क्या किया है:

[float(y) for y in x for x in l]

लेकिन फिर परिणाम 2400 के योग के साथ 100 का गुच्छा है।

किसी भी समाधान, एक स्पष्टीकरण बहुत सराहना की जाएगी। धन्यवाद!

Comments

क्या आप भी अपनी सूची को समतल करना चाहते हैं?

— ग्रेग हेवगिल

@GregHewgill: ओपी ने जवाब नहीं दिया, लेकिन उन्होंने जो जवाब स्वीकार किया, उसके आधार पर लगता है कि वे घोंसले को बनाए रखना चाहते थे।

— at

Answer 1

यहां बताया गया है कि आप नेस्टेड सूची की समझ के साथ ऐसा कैसे करेंगे:

[[float(y) for y in x] for x in l]

यह आपको सूचियों की एक सूची देगा, जैसा कि आपने स्ट्रिंग्स के बजाय फ़्लोट्स के अलावा शुरू किया था। यदि आप एक फ्लैट सूची चाहते हैं तो आप उपयोग करेंगे [float(y) for x in l for y in x]।

Answer 2

यहाँ बताया गया है कि नेस्टेड को लूप के लिए नेस्टेड लिस्ट में कैसे बदला जाए:

यहां बताया गया है कि नेस्टेड सूची समझ कैसे काम करती है:

            l a b c d e f
            ↓ ↓ ↓ ↓ ↓ ↓ ↓
In [1]: l = [ [ [ [ [ [ 1 ] ] ] ] ] ]
In [2]: for a in l:
   ...:     for b in a:
   ...:         for c in b:
   ...:             for d in c:
   ...:                 for e in d:
   ...:                     for f in e:
   ...:                         print(float(f))
   ...:                         
1.0

In [3]: [float(f)
         for a in l
   ...:     for b in a
   ...:         for c in b
   ...:             for d in c
   ...:                 for e in d
   ...:                     for f in e]
Out[3]: [1.0]

आपके मामले के लिए, यह कुछ इस तरह होगा।

In [4]: new_list = [float(y) for x in l for y in x]

Comments

सुपर उपयोगी! यह स्पष्ट करता है कि जनरेटर में छोरों (ऊपर से नीचे) को दाएं से बाएं क्रम में रखा गया है। यह स्पष्ट नहीं है क्योंकि (f(x) for x in l)बाईं ओर बराबर-लूप की दूसरी पंक्ति को रखता है।

— user48956

यह एक व्याख्या है जो वास्तव में मेरे साथ घर मार रहा है, धन्यवाद!

— डगलस प्लमले

Answer 3

>>> l = [['40', '20', '10', '30'], ['20', '20', '20', '20', '20', '30', '20'], ['30', '20', '30', '50', '10', '30', '20', '20', '20'], ['100', '100'], ['100', '100', '100', '100', '100'], ['100', '100', '100', '100']]
>>> new_list = [float(x) for xs in l for x in xs]
>>> new_list
[40.0, 20.0, 10.0, 30.0, 20.0, 20.0, 20.0, 20.0, 20.0, 30.0, 20.0, 30.0, 20.0, 30.0, 50.0, 10.0, 30.0, 20.0, 20.0, 20.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0]

Answer 4

निश्चित नहीं है कि आपका वांछित आउटपुट क्या है, लेकिन यदि आप सूची की समझ का उपयोग कर रहे हैं, तो आदेश नेस्टेड लूप के आदेश का पालन करता है, जिसे आप पीछे की ओर करते हैं। तो मुझे वही मिला जो मुझे लगता है कि आप चाहते हैं:

[float(y) for x in l for y in x]

सिद्धांत यह है: उसी आदेश का उपयोग करें जिसे आप इसे लिखने के लिए उपयोग करेंगे जैसा कि लूप के लिए नेस्टेड है।

Comments

इस, जवाब होना चाहिए कुछ समय के रूप में हम नहीं वर्ग कोष्ठक को iteratool चाहते

— zinking

यह सही उत्तर नहीं हो सकता है क्योंकि यह एक गैर नेस्टेड सूची को आउटपुट करता है, लेकिन यह वही है जो मैं देख रहा था, विशेष रूप से सिद्धांत । धन्यवाद!

— रोड्रिगो ई। प्रिंसिपल

Answer 5

चूँकि मैं यहाँ थोड़ी देर से हूँ, लेकिन मैं यह साझा करना चाहता था कि वास्तव में सूची समझ कैसे काम करती है विशेष रूप से नेस्टेड सूची समझ:

New_list= [[float(y) for x in l]

वास्तव में के रूप में ही है:

New_list=[]
for x in l:
    New_list.append(x)

और अब नेस्टेड सूची समझ:

[[float(y) for y in x] for x in l]

जैसा है;

new_list=[]
for x in l:
    sub_list=[]
    for y in x:
        sub_list.append(float(y))

    new_list.append(sub_list)

print(new_list)

उत्पादन:

[[40.0, 20.0, 10.0, 30.0], [20.0, 20.0, 20.0, 20.0, 20.0, 30.0, 20.0], [30.0, 20.0, 30.0, 50.0, 10.0, 30.0, 20.0, 20.0, 20.0], [100.0, 100.0], [100.0, 100.0, 100.0, 100.0, 100.0], [100.0, 100.0, 100.0, 100.0]]

Answer 6

यदि आपको नेस्टेड सूची की समझ नहीं है, तो आप मानचित्र फ़ंक्शन का भी उपयोग कर सकते हैं ,

>>> from pprint import pprint

>>> l = l = [['40', '20', '10', '30'], ['20', '20', '20', '20', '20', '30', '20'], ['30', '20', '30', '50', '10', '30', '20', '20', '20'], ['100', '100'], ['100', '100', '100', '100', '100'], ['100', '100', '100', '100']] 

>>> pprint(l)
[['40', '20', '10', '30'],
['20', '20', '20', '20', '20', '30', '20'],
['30', '20', '30', '50', '10', '30', '20', '20', '20'],
['100', '100'],
['100', '100', '100', '100', '100'],
['100', '100', '100', '100']]

>>> float_l = [map(float, nested_list) for nested_list in l]

>>> pprint(float_l)
[[40.0, 20.0, 10.0, 30.0],
[20.0, 20.0, 20.0, 20.0, 20.0, 30.0, 20.0],
[30.0, 20.0, 30.0, 50.0, 10.0, 30.0, 20.0, 20.0, 20.0],
[100.0, 100.0],
[100.0, 100.0, 100.0, 100.0, 100.0],
[100.0, 100.0, 100.0, 100.0]]

Comments

आपका कोड सूचियों के बजाय मानचित्र ऑब्जेक्ट्स उत्पन्न करता है: >>> float_l = [map(float, nested_list) for nested_list in l] [[<map at 0x47be9b0>], [<map at 0x47be2e8>], [<map at 0x47be4a8>], [<map at 0x47beeb8>], [<map at 0x484b048>], [<map at 0x484b0b8>]] लेकिन इसे सूचीबद्ध करने के लिए एक अतिरिक्त कॉल जोड़ने से यह उम्मीद के >>> float_l = [list(map(float, nested_list)) for nested_list in l]

— मुताबिक

@pixelperfect ( गलत सूचना ..) के कारण python3जेनरेटर्स को समझ से बाहर लौटने के लिए बदलते हैं ।

— javadba

Answer 7

मुझे हल करने के लिए इसी तरह की समस्या थी इसलिए मैं इस सवाल पर आया। मैंने एंड्रयू क्लार्क और नारायण के जवाब की तुलना की, जो मैं साझा करना चाहूंगा।

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

यह देखने के लिए कि क्या यह वास्तव में सच है, एक प्रदर्शन बेंचमार्क देता है। मैंने इन सभी परीक्षणों को करने के लिए अजगर संस्करण 3.5.0 का उपयोग किया। परीक्षणों के पहले सेट में मैं प्रति सूची तत्वों को 10 रखना चाहूँगा और 10-100,000 से सूचियों की संख्या को अलग-अलग करूँगा

>>> python -m timeit "[list(map(float,k)) for k in [list(range(0,10))]*10]"
>>> 100000 loops, best of 3: 15.2 usec per loop   
>>> python -m timeit "[[float(y) for y in x] for x in [list(range(0,10))]*10]"
>>> 10000 loops, best of 3: 19.6 usec per loop 

>>> python -m timeit "[list(map(float,k)) for k in [list(range(0,10))]*100]"
>>> 100000 loops, best of 3: 15.2 usec per loop
>>> python -m timeit "[[float(y) for y in x] for x in [list(range(0,10))]*100]"
>>> 10000 loops, best of 3: 19.6 usec per loop 

>>> python -m timeit "[list(map(float,k)) for k in [list(range(0,10))]*1000]"
>>> 1000 loops, best of 3: 1.43 msec per loop   
>>> python -m timeit "[[float(y) for y in x] for x in [list(range(0,10))]*1000]"
>>> 100 loops, best of 3: 1.91 msec per loop

>>> python -m timeit "[list(map(float,k)) for k in [list(range(0,10))]*10000]"
>>> 100 loops, best of 3: 13.6 msec per loop   
>>> python -m timeit "[[float(y) for y in x] for x in [list(range(0,10))]*10000]"
>>> 10 loops, best of 3: 19.1 msec per loop

>>> python -m timeit "[list(map(float,k)) for k in [list(range(0,10))]*100000]"
>>> 10 loops, best of 3: 164 msec per loop
>>> python -m timeit "[[float(y) for y in x] for x in [list(range(0,10))]*100000]"
>>> 10 loops, best of 3: 216 msec per loop

परीक्षणों के अगले सेट में मैं प्रति लिस्ट में तत्वों की संख्या बढ़ाकर 100 करना चाहूंगा ।

>>> python -m timeit "[list(map(float,k)) for k in [list(range(0,100))]*10]"
>>> 10000 loops, best of 3: 110 usec per loop
>>> python -m timeit "[[float(y) for y in x] for x in [list(range(0,100))]*10]"
>>> 10000 loops, best of 3: 151 usec per loop

>>> python -m timeit "[list(map(float,k)) for k in [list(range(0,100))]*100]"
>>> 1000 loops, best of 3: 1.11 msec per loop
>>> python -m timeit "[[float(y) for y in x] for x in [list(range(0,100))]*100]"
>>> 1000 loops, best of 3: 1.5 msec per loop

>>> python -m timeit "[list(map(float,k)) for k in [list(range(0,100))]*1000]"
>>> 100 loops, best of 3: 11.2 msec per loop
>>> python -m timeit "[[float(y) for y in x] for x in [list(range(0,100))]*1000]"
>>> 100 loops, best of 3: 16.7 msec per loop

>>> python -m timeit "[list(map(float,k)) for k in [list(range(0,100))]*10000]"
>>> 10 loops, best of 3: 134 msec per loop
>>> python -m timeit "[[float(y) for y in x] for x in [list(range(0,100))]*10000]"
>>> 10 loops, best of 3: 171 msec per loop

>>> python -m timeit "[list(map(float,k)) for k in [list(range(0,100))]*100000]"
>>> 10 loops, best of 3: 1.32 sec per loop
>>> python -m timeit "[[float(y) for y in x] for x in [list(range(0,100))]*100000]"
>>> 10 loops, best of 3: 1.7 sec per loop

आओ हम एक साहसी कदम उठाएँ और सूचियों में तत्वों की संख्या को 1000 तक संशोधित करें

>>> python -m timeit "[list(map(float,k)) for k in [list(range(0,1000))]*10]"
>>> 1000 loops, best of 3: 800 usec per loop
>>> python -m timeit "[[float(y) for y in x] for x in [list(range(0,1000))]*10]"
>>> 1000 loops, best of 3: 1.16 msec per loop

>>> python -m timeit "[list(map(float,k)) for k in [list(range(0,1000))]*100]"
>>> 100 loops, best of 3: 8.26 msec per loop
>>> python -m timeit "[[float(y) for y in x] for x in [list(range(0,1000))]*100]"
>>> 100 loops, best of 3: 11.7 msec per loop

>>> python -m timeit "[list(map(float,k)) for k in [list(range(0,1000))]*1000]"
>>> 10 loops, best of 3: 83.8 msec per loop
>>> python -m timeit "[[float(y) for y in x] for x in [list(range(0,1000))]*1000]"
>>> 10 loops, best of 3: 118 msec per loop

>>> python -m timeit "[list(map(float,k)) for k in [list(range(0,1000))]*10000]"
>>> 10 loops, best of 3: 868 msec per loop
>>> python -m timeit "[[float(y) for y in x] for x in [list(range(0,1000))]*10000]"
>>> 10 loops, best of 3: 1.23 sec per loop

>>> python -m timeit "[list(map(float,k)) for k in [list(range(0,1000))]*100000]"
>>> 10 loops, best of 3: 9.2 sec per loop
>>> python -m timeit "[[float(y) for y in x] for x in [list(range(0,1000))]*100000]"
>>> 10 loops, best of 3: 12.7 sec per loop

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

हालाँकि मुझे व्यक्तिगत रूप से सूची पढ़ने की क्षमता अधिक पढ़ने योग्य और मुहावरेदार लगती है map। यह अजगर में एक वास्तविक मानक है। आमतौर पर लोग सूची की समझ का उपयोग करने में अधिक कुशल और सहज (विशेष रूप से शुरुआती) होते हैं map।

Answer 8

हां, आप इसे ऐसे कोड के साथ कर सकते हैं:

l = [[float(y) for y in x] for x in l]

Comments

[float(y) for y in x for x in l]इसके परिणामस्वरूप 2400 की राशि के साथ 100 का एक गुच्छा होगा।

— बॉय पासमो

Answer 9

यह समस्या लूप का उपयोग किए बिना हल की जा सकती है। इसके लिए सिंगल लाइन कोड पर्याप्त होगा। लैम्ब्डा फ़ंक्शन के साथ नेस्टेड मैप का उपयोग करना भी यहां काम करेगा।

l = [['40', '20', '10', '30'], ['20', '20', '20', '20', '20', '30', '20'], ['30', '20', '30', '50', '10', '30', '20', '20', '20'], ['100', '100'], ['100', '100', '100', '100', '100'], ['100', '100', '100', '100']]

map(lambda x:map(lambda y:float(y),x),l)

और आउटपुट लिस्ट इस प्रकार होगी:

[[40.0, 20.0, 10.0, 30.0], [20.0, 20.0, 20.0, 20.0, 20.0, 30.0, 20.0], [30.0, 20.0, 30.0, 50.0, 10.0, 30.0, 20.0, 20.0, 20.0], [100.0, 100.0], [100.0, 100.0, 100.0, 100.0, 100.0], [100.0, 100.0, 100.0, 100.0]]

Comments

क्या लैंबडास के पास @Andrew Clark या हैरी बिन्सवांगर के समाधान (अधिक वैनिला सूची समझ) पर कोई प्रदर्शन लाभ है? जैसा कि लंबोदर पढ़ने में कठिन लगता है।

— स्टेफनजॉलियर

Answer 10

मेरी राय में ऐसा करने का सबसे अच्छा तरीका अजगर के itertoolsपैकेज का उपयोग करना है ।

>>>import itertools
>>>l1 = [1,2,3]
>>>l2 = [10,20,30]
>>>[l*2 for l in itertools.chain(*[l1,l2])]
[2, 4, 6, 20, 40, 60]

Answer 11

हां आप निम्न कार्य कर सकते हैं।

[[float(y) for y in x] for x in l]

Answer 12

    deck = [] 
    for rank in ranks:
        for suit in suits:
            deck.append(('%s%s')%(rank, suit))

यह सूची समझ का उपयोग करके प्राप्त किया जा सकता है:

[deck.append((rank,suit)) for suit in suits for rank in ranks ]

Comments

यह शीर्ष पर प्रश्न को संबोधित करने के लिए बिल्कुल भी प्रकट नहीं होता है। कृपया ध्यान दें कि उत्तर के रूप में पोस्ट की गई प्रत्येक चीज़ उस प्रश्न का उत्तर देने का प्रयास होना चाहिए, जिस पर उसे पोस्ट किया गया है।

— बौम Augen mit

हालांकि यह कोड स्निपेट प्रश्न को हल कर सकता है, जिसमें स्पष्टीकरण सहित वास्तव में आपकी पोस्ट की गुणवत्ता में सुधार करने में मदद करता है। याद रखें कि आप भविष्य में पाठकों के लिए प्रश्न का उत्तर दे रहे हैं, और उन लोगों को आपके कोड सुझाव के कारणों का पता नहीं चल सकता है। कृपया अपने कोड को व्याख्यात्मक टिप्पणियों के साथ भीड़ देने की कोशिश न करें, इससे कोड और स्पष्टीकरण दोनों की पठनीयता कम हो जाती है!

— फाइलनॉर

सूची बोध का उपयोग करते हुए लूप के लिए नेस्टेड,

— ADITYA KUMAR

ठीक है, तो जाहिर है, यह सवाल का जवाब देने का एक प्रयास है। हालाँकि, यह ओपी की तुलना में पूरी तरह से अलग परिदृश्य के बारे में प्रतीत होता है, आप इनपुट के रूप में नेस्टेड सूचियों के साथ भी व्यवहार नहीं करते हैं, और यहां तक ​​कि अगर आप बदलते हैं कि आपका सुझाव बहुत अधिक है जो ओपी पहले से ही कोशिश कर रहा है। इसके अलावा, मैं नहीं देखता कि कार्ड के बारे में एक उदाहरण कैसे मदद करता है जब सवाल स्ट्रिंग्स को फ्लोट में परिवर्तित करने के बारे में है।

— बौम Augen mit