Beberapa built-in untuk membuat daftar dengan python

Saya memiliki daftar ukuran < N dan saya ingin menambahkannya ke ukuran N dengan sebuah nilai.

Tentu saja, saya dapat menggunakan sesuatu seperti berikut ini, tetapi saya merasa ada sesuatu yang saya lewatkan:

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

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

atau jika Anda tidak ingin mengubah atempatnya

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

Anda selalu dapat membuat subkelas daftar dan memanggil metode ini sesuka Anda

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

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

Menurut saya pendekatan ini lebih visual dan pythonic.

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

Tidak ada fungsi bawaan untuk ini. Tapi Anda bisa membuat built-in untuk tugas Anda (atau apapun: p).

(Dimodifikasi dari itertool padnonedan takeresep)

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)

Pemakaian:

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

Jawaban gnibbler lebih bagus, tetapi jika Anda membutuhkan builtin, Anda dapat menggunakan itertools.izip_longest( zip_longestdi Py3k):

itertools.izip_longest( xrange( N ), list )

yang akan mengembalikan daftar tupel yang ( i, list[ i ] )diisi ke None. Jika Anda perlu menyingkirkan penghitung, lakukan sesuatu seperti:

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

Anda juga dapat menggunakan generator sederhana tanpa build in apa pun. Tetapi saya tidak akan mengisi daftar, tetapi membiarkan logika aplikasi menangani daftar kosong.

Bagaimanapun, iterator tanpa buildins

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()

Jika Anda ingin pad dengan Tidak Ada dan bukan '', map () melakukan pekerjaan:

>>> 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)

more-itertoolsadalah pustaka yang menyertakan paddedalat khusus untuk jenis masalah ini:

import more_itertools as mit

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

Sebagai alternatif, more_itertoolsterapkan juga resep itertools Python termasuk padnonedan takeseperti yang disebutkan oleh @kennytm, sehingga tidak harus diterapkan ulang:

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

Jika Anda ingin mengganti Nonepadding default , gunakan pemahaman daftar:

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

Untuk keluar dari 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]

Anda dapat menggunakan * operator unpacking yang dapat diulang :

N = 5
a = [1]

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

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

keluaran:

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

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

Ini menghindari alokasi tambahan, tidak seperti solusi apa pun yang bergantung pada pembuatan dan penambahan daftar [value] * extra_length. Pertama-tama, metode "perluasan" memanggil __length_hint__iterator, dan memperluas alokasi lsebanyak itu sebelum mengisinya dari iterator.