一些内置的在 python 中填充列表

我有一个大小 < N的列表，我想用一个值将它填充到大小 N。

当然，我可以使用下面这样的东西，但我觉得应该有我错过的东西:

>>> N = 5
>>> a = [1]
>>> map(lambda x, y: y if x is None else x, a, ['']*N)
[1, '', '', '', '']
91942 次浏览
小开
最佳答案 
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, '')
小开

Nibbler 的回答更好一些，但是如果您需要一个内置程序，您可以使用 itertools.izip_longest(Py3k 中的 zip_longest) :

itertools.izip_longest( xrange( N ), list )

它将返回填充的元组 ( i, list[ i ] )的列表。如果你需要摆脱柜台，可以这样做:

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

这里没有内置函数，但是您可以为您的任务(或任何东西: p)组成内置函数。

(根据 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, '', '', '', '']
小开

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

无论如何，没有构建的迭代器

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

脱离 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]
小开

我认为这种方法更加直观和简洁。

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

more-itertools 是一个库，其中包含一个专门用于解决这类问题的 padded工具:

import more_itertools as mit


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

另外，more_itertools还实现了 Python Itertools 食谱，包括@kennytm 提到的 padnone和 take，所以它们不需要重新实现:

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, '', '', '', '']
小开 
extra_length = desired_length - len(l)
l.extend(value for _ in range(extra_length))

这避免了任何额外的分配，不像任何依赖于创建和追加列表 [value] * extra_length的解决方案。“扩展”方法首先在迭代器上调用 __length_hint__，并在从迭代器填充之前将 l的分配扩展那么多。

小开

你可以使用 *可迭代解包算子:

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和其余的 ''。使用 a上的迭代器，我们获取所有可能的元素，当我们得到 StopIteration时，将返回 违约，即 ''。

小开

使用 np.repeat添加现有列表:

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

用空元素填充列表的一种简单方法是使用列表内涵。

        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 )]
小开

在元素列表之前添加填充

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

在元素列表之后添加填充

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

提交答案