rimozione di elementi vuoti finali in Python

Question

Esiste un modo elegante per far rimuovere gli elementi vuoti da una lista. Una sorta di list.rstrip (Nessuno). Così

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

dovrebbe comportare

[1, 2, 3, None, 4] 

Credo che questo possa essere generalizzato per la rimozione di elementi di trascinamento di qualsiasi particolare valore.

---

UPDATE: mi avrebbe dovuto precisare che io voglio che questo fatto come una singola linea (leggibile) espressione

Answer 1

A cura: Per utilizzare pop(), invece di tagliare la lista, come commentatori hanno correttamente suggerito.

Non so se c'è un modo più divinatorio, ma questo funziona:

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] 

Edit: Come @DSM fa notare, se si voleva solo per sbarazzarsi di None valori, e lasciare zeri o altri valori falsy, si potrebbe fare:

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

Answer 2

i seguenti controlli esplicitamente None elementi:

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

Si può essere generalizzato come segue:

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

È possibile ora definire le funzioni differenti per f per verificare la presenza di altre condizioni.

Answer 3

Prova questo

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

Answer 4

Per una soluzione di una sola riga:

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] 

Se si desidera riutilizzarlo, ecco una definizione in stile libero-point:

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

Ecco un altro 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] 

Queste cose sono divertenti!

EDIT

Ho appena realizzato che la lista di comprensione è completamente inutile. Slicing dovrebbe funzionare bene:

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

Answer 7

Se davvero è necessario compromettere la leggibilità, ecco cosa farei.

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

Che dire di ricorsione + affettatura?

>>> 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: Sto assumendo che non stai cercando la soluzione più efficiente computazionalmente qui ...

Answer 9

Che dire:

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

Answer 10

non ho mai accettato una risposta perché io non era davvero felice con le soluzioni offerte. Ecco un'altra soluzione (1 riga e senza dipendenze di libreria) che non sono del tutto soddisfatto con entrambi:

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

Il progetto more_itertools implementa rstrip per qualsiasi iterabile:

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 accetta un iterabile e il predicato . Vedi lo source code per i dettagli.