Algunos incorporados para rellenar una lista en python

Question

Tengo una lista del tamaño < N y quiero añadirle un tamaño de N con un valor.

Ciertamente, puedo usar algo como lo siguiente, pero siento que debe haber algo que había perdido:

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

Answer 1

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

o si no desea cambiar a en su lugar

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

siempre puede crear una subclase de lista y llamar al método lo que le plazca

respuesta

Answer 2

de gnibbler es mejor, pero si usted necesita una orden interna, se podría utilizar itertools.izip_longest (zip_longest en Py3k):

itertools.izip_longest(xrange(N), list) 

que devolverá una lista de tuplas (i, list[ i ]) rellenado en Ninguno. Si necesita deshacerse del contador, haga algo como:

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

Answer 3

No hay una función incorporada para esto. Pero podrías componer los built-in para tu tarea (o cualquier cosa: p).

(Modificado de itertool 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

También es posible usar un generador simple sin ningún ins de construcción. Pero no rellenaría la lista, pero dejarí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 5

Si quieren almohadilla con ninguno en lugar de '', del mapa() 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

ir fuera 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 7

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

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

Answer 8

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

import more_itertools as mit 

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

---

Como alternativa, también se implementa more_itertools Python itertools recipes incluyendo padnone y take como se ha mencionado por @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 por defecto None, utilice una lista de comprensión:

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