eliminación de elementos vacíos finales en Python

Question

¿Existe una forma elegante de python para eliminar elementos vacíos de una lista? Una especie de list.rstrip (Ninguno). Así

[1, 2, 3, None, 4, None, None] 

debería resultar en

[1, 2, 3, None, 4] 

supongo que esto podría ser generalizado a la eliminación de los elementos de salida de cualquier valor particular.

---

ACTUALIZACIÓN: Yo debería haber especificado que quiero que este hecho como una sola línea (legible) la expresión

Answer 1

Editado: Para utilizar pop() en lugar de cortar la lista, como comentaristas tienen correctamente sugerido.

No sé si hay una manera más Pythonic, pero esto funciona:

my_list = [1, 2, 3, None, 4, None, None] 
while not my_list[-1]: 
    my_list.pop() 
print my_list 
>>>[1, 2, 3, None, 4] 

Editar: Como @DSM señala, si sólo quería deshacerse de None valores y dejar ceros u otros valores Falsy, que podían hacer:

while my_list and my_list[-1] is None: 
    my_list.pop() 

Answer 2

las siguientes comprobaciones explícitamente None elementos:

while l and l[-1] is None: 
    l.pop() 

se puede generalizar de la siguiente manera:

f = lambda x: x is None 
while l and f(l[-1]): 
    l.pop() 

Ahora puede definir diferentes funciones para f para comprobar si hay otras condiciones.

Answer 3

Prueba este

>>> x=[1, 2, 3, None, 4, None, None] 
>>> while x[-1] is None: 
    x.pop() 

Answer 4

Para una solución de una sola línea:

In [30]: from itertools import dropwhile 

In [31]: list(reversed(tuple(dropwhile(lambda x: x is None, reversed([1, 2, 3, None, 4, None, None]))))) 
Out[31]: [1, 2, 3, None, 4] 

Si desea volver a utilizar, aquí está una definición de estilo libre de puntos:

In [36]: from functional import compose, partial 

In [37]: varargs = lambda *args: args 

In [38]: compose_mult = compose(partial(reduce, compose),varargs) # compose which takes variable number of arguments. Innermost function to the right. 

In [39]: compose_mult(list, reversed, tuple, partial(dropwhile, lambda x: x is None), reversed)([1, 2, 3, None, 4, None, None]) 
Out[39]: [1, 2, 3, None, 4] 

Answer 5

def remove_trailing(l, remove_value=None): 
     i = len(l) 
     while i>0 and l[i-1] == remove_value: 
      i -= 1 
     return l[:i] 

Answer 6

Aquí hay otro one-liner:

>>> l = [1, 2, 3, None, 4, None, None] 
>>> [l[i] for i in range(len("".join(map(lambda x: {None: " "}.get(x, "_"), l)).rstrip()))] 
[1, 2, 3, None, 4] 

¡Estas cosas son divertidas!

EDITAR

me he dado cuenta de que la lista de comprensión es completamente innecesario. Rebanar debería funcionar bien:

>>> l[:len("".join(map(lambda x: {None: " "}.get(x, "_"), l)).rstrip())] 

Answer 7

Si realmente necesita comprometer la legibilidad esto es lo que yo haría.

>>> from itertools import takewhile 
>>> l=[1,2,3,None,4,5,None,None] 
>>> l[:-len(list(takewhile(lambda x: x==None, reversed(l))))] 
[1,2,3,None,4,5] 

Answer 8

¿Qué hay de recursion + slicing?

>>> rstrip = lambda x, elts=(None,): rstrip(x[:-1], elts) if x and x[-1] in elts else x 
>>> rstrip([1, 2, 3, None]) 
[1, 2, 3] 
>>> rstrip([1, 2, 3, None], (None, 3)) 
[1, 2] 

Nota: Estoy asumiendo que usted no está buscando la solución más eficiente computacionalmente aquí ...

Answer 9

¿Qué hay de:

[a[i] for i in range(len(a)) if a[i:] != [None] * (len(a) - i) ] 

Answer 10

Nunca acepté una respuesta porque no estaba realmente feliz con las soluciones ofrecidas. Aquí hay otra solución (1 línea y sin dependencias de la biblioteca) que no estoy del todo contento con:

a = [1, 2, None, 3, None, None] 
reduce(lambda l, e: [e]+l if l or e is not None else [], reversed(a), []) 

Answer 11

El proyecto more_itertools implementa rstrip para cualquier iterable:

iterable = [1, 2, 3, None, 4, None, None] 
list(mit.rstrip(iterable, lambda x: x in {None})) 
# [1, 2, 3, None, 4] 

more_itertools.rstrip acepta un iterable y predicado . Vea el source code para más detalles.