在python中有一些内置的

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

或者如果你不想改变 a 到位

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

您可以创建list的子类,并根据需要调用该方法

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

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

我认为这种方法更具视觉效果和感染力。

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

没有用于此的内置函数。但是您可以为您的任务(或任何东西)编写内置程序。

(根据itertool的 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, '', '', '', '']

gnibbler的答案更好,但如果你需要一个内置的,你可以使用 itertools.izip_longest zip_longest 在Py3k中):

itertools.izip_longest( xrange( N ), list )

它将返回一个元组列表 ( i, list[ i ] ) 填写为“无”。如果您需要摆脱计数器,请执行以下操作:

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

more-itertools 是一个图书馆,包括一个特殊的 padded 解决此类问题的工具:

import more_itertools as mit

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

或者, more_itertools 还实现了Python itertools recipes 包括 padnone take 正如@kennytm所提到的,因此它们不必重新实现:

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, '', '', '', '']

您也可以使用一个没有任何内置的简单生成器。 但是我不会填充列表,而是让应用程序逻辑处理一个空列表。

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

如果要用“无”而不是“”填充,map()将执行以下操作:

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

离开肯尼特:

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]

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

这避免了任何额外的分配,不像任何依赖于创建和附加列表的解决方案 [value] * extra_length __length_hint__ 并扩展了 l 在从迭代器填充之前。

你可以用 * iterable unpacking operator

N = 5
a = [1]

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

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

输出:

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

使用迭代器并利用 违约 next :

i = iter(a)
a = [next(i, '') for _ in range(N)]

无论哪种方式我们都想生产 N for _ in range(N) . 那么我们应该尽可能地从 a 其他的呢 '' . 在上使用迭代器 一 我们抓住了所有可能的元素 StopIteration 违约 '' .

添加到现有列表 np.repeat

import numpy as np
a + list(np.repeat([''], (N - len(a))))

用空元素填充列表的一种pythonic方法是使用列表理解。

        my_list = [1,2]
        desired_len = 3
        # Ensure that the length of my list is 3 elements
        [my_list.extend(['']) for _ in range(desired_len - len(my_list))]
        [my_list.pop() for _ in range(len(my_list)-desired_len )]