यह फ़ंक्शन क्या करता है? (पायथन इटरेटर्स)

def partition(n, iterable): 
    p = izip_longest(*([iter(iterable)] * n)) 
    r = [] 
    for x in p: 
     print(x) #I added this 
     s = set(x) 
     s.discard(None) 
     r.append(list(s)) 
    return r

यह वास्तव में एसओ पर नौकरी पोस्ट करने और नौसिखिया होने पर मुझे लगता है कि यह दिलचस्प था। तो अगर आप की तरह आउटपुट प्राप्त निम्नलिखित:यह फ़ंक्शन क्या करता है? (पायथन इटरेटर्स)

partition(5, L) 
(1, 2, 3, 4, None) 
Out[86]: [[1, 2, 3, 4]]

मुझे इस के लिए पहले से ही भ्रमित क्योंकि मैंने सोचा izip_longest(*([iter(iterable)] * n)) n समान iterators की एक सूची पर izip_longest समारोह चल पाएंगे तो मैं पहले (1,1,1,1,1) और फिर एक का उत्पादन की उम्मीद है | है (2,2,2,2,2) और इतने पर आउटपुट।

मेरे सवाल का तो लघु संस्करण, है क्या पर इस लाइन के साथ जा रहा है:

p = izip_longest(*([iter(iterable)] * n))

यह पार्स मैं सोचा होगा [आईटीईआर (iterable)] * n समान iterables की लंबाई n सभी की एक सूची बनाता है एक ही बात की ओर इशारा करते हुए - यह कमांड लाइन पर यही करता है, लेकिन यह उपरोक्त मुद्रित आउटपुट के आधार पर ऐसा नहीं लगता है।

इसके अलावा मैंने सोचा कि * शुरुआत में * ...longest(*... सूची अज्ञात लंबाई की है, लेकिन मुझे नहीं लगता कि पूरी तरह से समझ में आता है। फ़ंक्शन कॉल के अंदर ऐसा पहला * प्रतीक क्या है? ऐसा प्रतीत नहीं होता है कि यह तर्कों की अज्ञात लंबाई सूची को इंगित करता है ...

तो दिन के अंत में मैं पूरी तरह से खो गया हूं। क्या कोई मुझे इस वाक्यविन्यास के माध्यम से चल सकता है?

धन्यवाद किसी भी इनपुट के लिए बहुत कुछ!

सभी सहायक उत्तरों के लिए धन्यवाद, हर कोई। मुझे यकीन नहीं है कि क्या मैं यहां किसी उत्तर या प्रश्न पर काम कर रहा हूं, लेकिन ऐसा लगता है कि यह सूची समझ सूचियों और टुपल्स के लिए एक ही काम करेगी (मुझे एहसास है कि यह भी शब्दकोशकारियों, कस्टम वर्गों, अन्य चीजों पर लागू होगा .. ।)

[L[i*n:(i+1)*n] for i in range(int(ceil(len(L)/float(n)))) ]

स्रोत

2015-05-21 sunny

आप पढ़ सकते हैं [कैसे 'जिप (* [आईटीईआर (रों)] * एन)' पायथन में काम] (http://stackoverflow.com/questions/2233204/how- करता है-zipitersn-कार्य में अजगर)? –

यह एन आकार की छोटी सूचियों में एक बड़ी सूची तोड़ता है .... इस घटना में कोई भी नहीं भर रहा है कि सूची की लंबाई एन द्वारा समान रूप से विभाजित नहीं है ... केवल एक ही उपन्यास जिसमें कोई भी 'कोई नहीं' होना चाहिए अंतिम सूची –

जोड़ें 'izip_longest()' क्या किया गया यह देखने के लिए 'प्रिंट (सूची (पी))'। – martineau

को देखते हुए के साथ इसे आसान बनाने सकता है:

>>> li 
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]

वहाँ एक है और * operator के साथ संयोजन में zip का उपयोग करने के सामान्य पायथन मुहावरे की सूची को विभाजित करने के लिए एन लंबाई की सूचियों की सूची में एक फ्लैट सूची:

>>> n=3 
>>> zip(*([iter(li)] * n)) 
[(0, 1, 2), (3, 4, 5), (6, 7, 8), (9, 10, 11), (12, 13, 14), (15, 16, 17), (18, 19, 20)]

हालांकि, अगर n कुल लंबाई का एक और भी कई नहीं है, अंतिम सूची छोटा किया गया है:

>>> n=4 
>>> zip(*([iter(li)] * n)) 
[(0, 1, 2, 3), (4, 5, 6, 7), (8, 9, 10, 11), (12, 13, 14, 15), (16, 17, 18, 19)]

आप पूरा करने के लिए एक चयनित मान के साथ में भरा सूची का उपयोग करने izip_longest उपयोग कर सकते हैं अधूरा उप सूचियां:

>>> list(izip_longest(*([iter(li)] * n))) 
[(0, 1, 2, 3), (4, 5, 6, 7), (8, 9, 10, 11), (12, 13, 14, 15), (16, 17, 18, 19), (20, None, None, None)]

स्रोत

2015-05-21 16:54:59 dawg

यह बताते हुए अच्छा जवाब क्यों दिया गया कि वह क्यों नहीं मिला और इसका उपयोग क्यों कर रहा है izip_longest :) +1 –

@dawg धन्यवाद बहुत। यह वास्तव में अच्छा है। – sunny

यह ध्यान दिया जाना चाहिए कि जिस तरह से अतिरिक्त 'कोई भी नहीं हटाया जा रहा है, उसके परिणामस्वरूप' कोई नहीं 'वाले पुनरावृत्त इस फ़ंक्शन द्वारा असमर्थित हैं। उदाहरण के लिए, 'विभाजन (2, [1,2, कोई नहीं, 4,5]) '' [[1, 2], [4], [5]] देता है। मुझे लगता है कि एक कस्टम बनाया सेंटीनेल मूल्य का उपयोग करने के लिए यह और अधिक मजबूत होता। – jpmc26

iter(my_list) में एक सूची धर्मान्तरित एक iterable (जो) एक जहाँ तत्वों खपत होती है के रूप में वे देखा जाता है

[my_iter]*5 जिसमें एक ही करने के लिए सभी my_iter के बिंदु [my_iter,my_iter,my_iter,my_iter,my_iter] की एक नई सूची बनाता है सटीक इटरेटर

zip(*[my_iter,my_iter,my_iter,my_iter,my_iter])

zip(my_iter,my_iter,my_iter,my_iter,my_iter)

0 रूप में ही है

जो मूल रूप से सिर्फ एक 5xlen(my_list)//5 2d सूची लौटाती है (सूचक बस एक सूची/टपल unpacks)

आप सामान्य जिप

#this method will have no `None` entries 
new_list_partitioned = zip(*[iter(big_list)]*N) + [big_list[-(len(big_list)%N):],]

स्रोत

2015-05-21 16:47:32

यदि आप मेरे प्रश्न को देखते हैं, तो मुझे वह हिस्सा मिला। जो मुझे नहीं मिला था, वह क्यों था [iter (... – sunny

यह सूची को अनपैक करता है ... –

यह फ़ंक्शन क्या करता है? (पायथन इटरेटर्स)

उत्तर

संबंधित मुद्दे