Einige sind integriert, um eine Liste in Python aufzufüllen

Ich habe eine Liste mit der Größe < N und möchte sie mit einem Wert auf die Größe N auffüllen.

Natürlich kann ich so etwas wie das Folgende verwenden, aber ich bin der Meinung, dass es etwas geben sollte, das ich verpasst habe:

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

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

oder wenn Sie nicht an aOrt und Stelle ändern möchten

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

Sie können jederzeit eine Unterklasse von Listen erstellen und die Methode nach Belieben aufrufen

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

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

Ich denke, dieser Ansatz ist visueller und pythonischer.

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

Hierfür gibt es keine eingebaute Funktion. Sie können jedoch die integrierten Funktionen für Ihre Aufgabe erstellen (oder alles: p).

(Geändert von itertools padnoneund takeRezepten)

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)

Verwendung:

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

Die Antwort von gnibbler ist besser, aber wenn Sie ein eingebautes benötigen, können Sie Folgendes verwenden itertools.izip_longest( zip_longestin Py3k):

itertools.izip_longest( xrange( N ), list )

Dadurch wird eine Liste der ( i, list[ i ] )ausgefüllten Tupel an None zurückgegeben. Wenn Sie die Theke loswerden müssen, gehen Sie wie folgt vor:

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

Sie können auch einen einfachen Generator ohne Einbauten verwenden. Aber ich würde die Liste nicht auffüllen, sondern die Anwendungslogik mit einer leeren Liste umgehen lassen.

Jedenfalls Iterator ohne 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()

Wenn Sie mit None anstelle von '' auffüllen möchten, erledigt map () die Aufgabe:

>>> 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-itertoolsist eine Bibliothek, die ein spezielles paddedTool für diese Art von Problem enthält:

import more_itertools as mit

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

Alternativ können more_itertoolsauch Python- itertools-Rezepte implementiert werden, einschließlich padnoneund takewie von @kennytm erwähnt, sodass sie nicht erneut implementiert werden müssen:

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

Wenn Sie die Standardauffüllung ersetzen möchten None, verwenden Sie ein Listenverständnis:

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

Kennytm verlassen:

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]

Sie können den * iterierbaren Entpackungsoperator verwenden :

N = 5
a = [1]

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

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

Ausgabe:

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

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

Dies vermeidet jede zusätzliche Zuordnung, im Gegensatz zu jeder Lösung, die vom Erstellen und Anhängen der Liste abhängt [value] * extra_length. Die "verlängern" -Methode ruft zuerst __length_hint__den Iterator auf und erweitert die Zuordnung um ldiesen Betrag, bevor sie vom Iterator ausgefüllt wird.