कुछ अंतर्निहित अजगर में एक सूची पैड करने के लिए

Question

मेरे पास आकार की एक सूची है < N और मैं इसे एक मूल्य के साथ आकार N तक पैड करना चाहता हूं।

निश्चित रूप से, मैं निम्नलिखित जैसे कुछ का उपयोग कर सकता हूं, लेकिन मुझे लगता है कि कुछ ऐसा होना चाहिए जिसे मैंने याद किया है:

>>> N = 5
>>> a = [1]
>>> map(lambda x, y: y if x is None else x, a, ['']*N)
[1, '', '', '', '']

Comments

तुम ऐसा क्यों करना चाहते हो? शायद एक बेहतर तरीका है।

— कैटरियल

मैं सूची को स्तंभों की निश्चित संख्या के साथ एक टैब से अलग स्ट्रिंग में क्रमबद्ध करता हूं।

— newtover

क्या आपका मतलब है कि आप कुछ ऐसा कर रहे हैं जैसे '' t.join ([1, '', '', '', ''))? शायद आप हमें इस बारे में अधिक बता सकते हैं कि आप क्या लागू करना चाहते हैं, तो हम एक विचार के साथ आने की कोशिश कर सकते हैं।

— सटोरू

@ Satoru.Logic: हाँ, प्रिंट >> a_stream, '\ t'.join (the_list) सभी मैं लागू करना चाहता हूं

— newtover

Answer 1

a += [''] * (N - len(a))

या यदि आप aजगह में परिवर्तन नहीं करना चाहते हैं

new_a = a + [''] * (N - len(a))

आप हमेशा सूची का एक उपवर्ग बना सकते हैं और विधि को कॉल कर सकते हैं जो भी आप चाहते हैं

class MyList(list):
    def ljust(self, n, fillvalue=''):
        return self + [fillvalue] * (n - len(self))

a = MyList(['1'])
b = a.ljust(5, '')

Comments

यह बहुत बेहतर लग रहा है, लेकिन मैं अभी भी एक भरने या पैड विधि या कार्य =) की तरह कुछ उम्मीद करता हूं

— newtover

Answer 2

मुझे लगता है कि यह दृष्टिकोण अधिक दृश्य और पाइथोनिक है।

a = (a + N * [''])[:N]

Comments

मुझे समझने में आधा मिनट लगता है। स्वीकृत उत्तर बहुत अधिक सीधा है।

— रिचर्ड मोहन

@ रिचर्डमोहन "पायथोनिक" का अर्थ है "मुहावरेदार"। जितना अधिक आप पायथन का उपयोग करेंगे, उतना अधिक प्राकृतिक आप इस वाक्यविन्यास को पाएंगे।

— नूनो एंड्रे

मुझे पता है कि 'पायथोनिक' का क्या मतलब है। और मैं 2014 से लगातार पायथन का उपयोग कर रहा हूं। मुझे अभी भी आपका उत्तर स्वाभाविक नहीं मिला है।

— रिचर्ड मोहन

इंटरमीडिएट थ्रो-लिस्ट का निर्माण करने के लिए उसे क्या चाहिए?

— डायलनयुंग

@DylanYoung पहली बार ऐसा नहीं है N < len(a)। यह आपके द्वारा दिए गए दूसरे उत्तर के लिए मामला है।

— कोन साइक

Answer 3

इसके लिए कोई अंतर्निहित फ़ंक्शन नहीं है। लेकिन आप अपने कार्य (या कुछ भी: पी) के लिए बिल्ट-इन बना सकते हैं।

(इटर्टूल padnoneऔर takeव्यंजनों से संशोधित )

from itertools import chain, repeat, islice

def pad_infinite(iterable, padding=None):
   return chain(iterable, repeat(padding))

def pad(iterable, size, padding=None):
   return islice(pad_infinite(iterable, padding), size)

उपयोग:

>>> list(pad([1,2,3], 7, ''))
[1, 2, 3, '', '', '', '']

Answer 4

gnibbler का उत्तर अच्छा है, लेकिन यदि आपको एक बिलिन की आवश्यकता है, तो आप उपयोग कर सकते हैं itertools.izip_longest( zip_longestPy3k में):

itertools.izip_longest( xrange( N ), list )

जो किसी ( i, list[ i ] )को भी भरे हुए tuples की सूची लौटाएगा । यदि आपको काउंटर से छुटकारा पाने की आवश्यकता है, तो कुछ ऐसा करें:

map( itertools.itemgetter( 1 ), itertools.izip_longest( xrange( N ), list ) )

Comments

मैं izip_longest के बारे में जानता था, लेकिन परिणाम अच्छा नहीं दिखता =)

— newtover

मेरा मानना ​​है कि आप का मतलब है operator.itemgetter()। इसके अलावा Noneमूल्यों को बदलने की जरूरत है ""।

— पाइलैंग

Answer 5

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

किसी भी तरह, बिल्डरों के बिना चलने वाला

def pad(iterable, padding='.', length=7):
    '''
    >>> iterable = [1,2,3]
    >>> list(pad(iterable))
    [1, 2, 3, '.', '.', '.', '.']
    '''
    for count, i in enumerate(iterable):
        yield i
    while count < length - 1:
        count += 1
        yield padding

if __name__ == '__main__':
    import doctest
    doctest.testmod()

Answer 6

यदि आप '' के बजाय किसी के साथ पैड करना चाहते हैं, तो मैप () काम करता है:

>>> map(None,[1,2,3],xrange(7))

[(1, 0), (2, 1), (3, 2), (None, 3), (None, 4), (None, 5), (None, 6)]

>>> zip(*map(None,[1,2,3],xrange(7)))[0]

(1, 2, 3, None, None, None, None)

Comments

खुलकर कहने के लिए, एक + [''] * (एन-लेन (ए)) बहुत स्पष्ट दिखता है। इसके अलावा, यह सूची में कास्टिंग का अभाव है। लेकिन फिर भी धन्यवाद।

— न्यूटवर

Answer 7

more-itertoolsएक पुस्तकालय है जिसमें paddedइस तरह की समस्या के लिए एक विशेष उपकरण शामिल है:

import more_itertools as mit

list(mit.padded(a, "", N))
# [1, '', '', '', '']

---

वैकल्पिक रूप से, more_itertoolsयह भी लागू करता अजगर व्यंजनों itertools सहित padnoneऔर takeके रूप में @kennytm से उल्लेख किया है, वे reimplemented किए जाने की जरूरत नहीं है तो:

list(mit.take(N, mit.padnone(a)))
# [1, None, None, None, None]

यदि आप डिफ़ॉल्ट Noneपैडिंग को बदलना चाहते हैं , तो सूची बोध का उपयोग करें:

["" if i is None else i for i in mit.take(N, mit.padnone(a))]
# [1, '', '', '', '']

Answer 8

Kennytm से दूर जाने के लिए:

def pad(l, size, padding):
    return l + [padding] * abs((len(l)-size))

>>> l = [1,2,3]
>>> pad(l, 7, 0)
[1, 2, 3, 0, 0, 0, 0]

Answer 9

आप * iterable अनपैकिंग ऑपरेटर का उपयोग कर सकते हैं :

N = 5
a = [1]

pad_value = ''
pad_size = N - len(a)

final_list = [*a, *[pad_value] * pad_size]
print(final_list)

उत्पादन:

[1, '', '', '', '']

Answer 10

extra_length = desired_length - len(l)
l.extend(value for _ in range(extra_length))

यह किसी भी समाधान के विपरीत किसी भी अतिरिक्त आवंटन से बचता है, जो सूची बनाने और जोड़ने पर निर्भर करता है [value] * extra_length। "विस्तार" विधि पहले इट्रेटर __length_hint__पर कॉल करती है, और lइट्रेटर से इसे भरने से पहले इसके द्वारा आवंटन का विस्तार करती है।