sirve - lista dinamica python

Algunos incorporados para rellenar una lista en python

Question

Tengo una lista de tamaño < N y quiero rellenarla con un valor al tamaño N.

Ciertamente, puedo usar algo como lo siguiente, pero siento que debería haber algo que me perdí:

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

Answer 1

Creo que este enfoque es más visual y más pitón.

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

Answer 2

La respuesta de gnibbler es más agradable, pero si necesita un componente incorporado, puede usar itertools.izip_longest ( zip_longest en Py3k):

itertools.izip_longest( xrange( N ), list )

que devolverá una lista de tuplas ( i, list[ i ] ) rellenada a Ninguna. Si necesitas deshacerte del contador, haz algo como:

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

Answer 3

No hay una función incorporada para esto. Pero podría componer las incorporaciones para su tarea (o cualquier otra cosa: p).

(Modificado del padnone de padnone y take recetas)

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)

Uso:

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

Answer 4

Salir de 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 5

Si desea rellenar con Ninguno en lugar de '''', map () hace el trabajo:

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

Answer 6

También puede utilizar un generador simple sin ningún tipo de complementos. Pero no rellenaría la lista, pero permitiría que la lógica de la aplicación tratara con una lista vacía.

De todos modos, iterador sin 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()

Answer 7

more-itertools es una biblioteca que incluye una herramienta padded especial para este tipo de problema:

import more_itertools as mit

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

Alternativamente, more_itertools también implementa recetas de itertoles de Python , incluyendo padnone y take como lo menciona @kennytm, para que no tengan que volver a implementarse:

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

Si desea reemplazar el relleno predeterminado, use una lista de comprensión:

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

Answer 8

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

o si no quieres cambiar a en lugar

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

Siempre puedes crear una subclase de lista y llamar al método lo que quieras.

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

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