Voglio rimuovere tutte le stringhe vuote da un elenco di stringhe in Python.

La mia idea è simile a questa:

while '' in str_list:
    str_list.remove('')

Esiste un modo più pitone per farlo?

Vorrei usare filter:

str_list = filter(None, str_list)
str_list = filter(bool, str_list)
str_list = filter(len, str_list)
str_list = filter(lambda item: item, str_list)

Python 3 restituisce un iteratore da filter, quindi dovrebbe essere racchiuso in una chiamata alist()

str_list = list(filter(None, str_list))

L'uso della comprensione di un elenco è il modo più pitonico:

>>> strings = ["first", "", "second"]
>>> [x for x in strings if x]
['first', 'second']

Se l'elenco deve essere modificato sul posto, poiché esistono altri riferimenti che devono visualizzare i dati aggiornati, utilizzare un'assegnazione di sezione:

strings[:] = [x for x in strings if x]

Il filtro ha in realtà un'opzione speciale per questo:

filter(None, sequence)

Filtrerà tutti gli elementi che valutano Falso. Non c'è bisogno di usare un vero callable qui come bool, len e così via.

È altrettanto veloce della mappa (bool, ...)

>>> lstr = ['hello', '', ' ', 'world', ' ']
>>> lstr
['hello', '', ' ', 'world', ' ']

>>> ' '.join(lstr).split()
['hello', 'world']

>>> filter(None, lstr)
['hello', ' ', 'world', ' ']

Confronta il tempo

>>> from timeit import timeit
>>> timeit('" ".join(lstr).split()', "lstr=['hello', '', ' ', 'world', ' ']", number=10000000)
4.226747989654541
>>> timeit('filter(None, lstr)', "lstr=['hello', '', ' ', 'world', ' ']", number=10000000)
3.0278358459472656

Si noti che filter(None, lstr)non rimuove stringhe vuote con uno spazio ' ', si pota solo via ''mentre ' '.join(lstr).split()rimuove entrambi.

Per utilizzare filter()con le stringhe di spazio bianco rimosse, ci vuole molto più tempo:

>>> timeit('filter(None, [l.replace(" ", "") for l in lstr])', "lstr=['hello', '', ' ', 'world', ' ']", number=10000000)
18.101892948150635

La risposta di @ Ib33X è fantastica. Se vuoi rimuovere ogni stringa vuota, dopo averla rimossa. è necessario utilizzare anche il metodo strip. Altrimenti, restituirà anche la stringa vuota se ha spazi bianchi. Ad esempio, "" sarà valido anche per quella risposta. Quindi, può essere raggiunto da.

strings = ["first", "", "second ", " "]
[x.strip() for x in strings if x.strip()]

La risposta per questo sarà ["first", "second"].
Se vuoi usare filterinvece il metodo, puoi fare come
list(filter(lambda item: item.strip(), strings)). Questo è dare lo stesso risultato.

Invece di se x, userei se X! = '' Per eliminare solo le stringhe vuote. Come questo:

str_list = [x for x in str_list if x != '']

Ciò conserverà il tipo di dati Nessuno nell'elenco. Inoltre, nel caso in cui la tua lista abbia numeri interi e 0 sia uno tra questi, verrà anche conservato.

Per esempio,

str_list = [None, '', 0, "Hi", '', "Hello"]
[x for x in str_list if x != '']
[None, 0, "Hi", "Hello"]

A seconda delle dimensioni del tuo elenco, potrebbe essere più efficace se usi list.remove () anziché creare un nuovo elenco:

l = ["1", "", "3", ""]

while True:
  try:
    l.remove("")
  except ValueError:
    break

Questo ha il vantaggio di non creare un nuovo elenco, ma lo svantaggio di dover cercare dall'inizio ogni volta, anche se a differenza di while '' in lcome proposto sopra, richiede solo una ricerca per occorrenza di ''(c'è sicuramente un modo per mantenere il meglio di entrambi i metodi, ma è più complicato).

Tieni presente che se vuoi mantenere gli spazi bianchi all'interno di una stringa , puoi rimuoverli involontariamente usando alcuni approcci. Se hai questo elenco

['ciao mondo', '', '', 'ciao'] cosa potresti desiderare ['ciao mondo', 'ciao']

tagliare prima l'elenco per convertire qualsiasi tipo di spazio bianco in stringa vuota:

space_to_empty = [x.strip() for x in _text_list]

quindi rimuovere la stringa vuota dall'elenco

space_clean_list = [x for x in space_to_empty if x]

Utilizzare filter:

newlist=filter(lambda x: len(x)>0, oldlist) 

Gli svantaggi dell'utilizzo del filtro come sottolineato è che è più lento delle alternative; inoltre, di lambdasolito è costoso.

Oppure puoi scegliere il più semplice e il più iterativo di tutti:

# I am assuming listtext is the original list containing (possibly) empty items
for item in listtext:
    if item:
        newlist.append(str(item))
# You can remove str() based on the content of your original list

questo è il metodo più intuitivo e lo fa in tempo decente.

Come riportato da Aziz Alto filter(None, lstr) non rimuove le stringhe vuote con uno spazio ' 'ma se sei sicuro che lstr contenga solo stringhe puoi usarefilter(str.strip, lstr)

>>> lstr = ['hello', '', ' ', 'world', ' ']
>>> lstr
['hello', '', ' ', 'world', ' ']
>>> ' '.join(lstr).split()
['hello', 'world']
>>> filter(str.strip, lstr)
['hello', 'world']

Confronta i tempi sul mio pc

>>> from timeit import timeit
>>> timeit('" ".join(lstr).split()', "lstr=['hello', '', ' ', 'world', ' ']", number=10000000)
3.356455087661743
>>> timeit('filter(str.strip, lstr)', "lstr=['hello', '', ' ', 'world', ' ']", number=10000000)
5.276503801345825

Rimane la soluzione più veloce per rimuovere ''e svuotare le stringhe con uno spazio .' '' '.join(lstr).split()

Come riportato in un commento, la situazione è diversa se le stringhe contengono spazi.

>>> lstr = ['hello', '', ' ', 'world', '    ', 'see you']
>>> lstr
['hello', '', ' ', 'world', '    ', 'see you']
>>> ' '.join(lstr).split()
['hello', 'world', 'see', 'you']
>>> filter(str.strip, lstr)
['hello', 'world', 'see you']

Puoi vedere che filter(str.strip, lstr)preserva le stringhe con degli spazi, ma ' '.join(lstr).split()le suddividerà.

Riassumi le migliori risposte:

1. Elimina i vuoti SENZA stripping:

Cioè, le stringhe per tutti gli spazi vengono mantenute:

slist = list(filter(None, slist))

Professionisti:

• più semplice;
• più veloce (vedere i benchmark di seguito).

2. Per eliminare i vuoti dopo lo stripping ...

2.a ... quando le stringhe NON contengono spazi tra le parole:

slist = ' '.join(slist).split()

Professionisti:

• piccolo codice
• veloce (MA non più veloce con grandi set di dati a causa della memoria, contrariamente a quanto risulta da @ paolo-melchiorre)

2.b ... quando le stringhe contengono spazi tra le parole?

slist = list(filter(str.strip, slist))

Professionisti:

• più veloce;
• comprensibilità del codice.

Benchmark su una macchina 2018:

## Build test-data
#
import random, string
nwords = 10000
maxlen = 30
null_ratio = 0.1
rnd = random.Random(0)                  # deterministic results
words = [' ' * rnd.randint(0, maxlen)
         if rnd.random() > (1 - null_ratio)
         else
         ''.join(random.choices(string.ascii_letters, k=rnd.randint(0, maxlen)))
         for _i in range(nwords)
        ]

## Test functions
#
def nostrip_filter(slist):
    return list(filter(None, slist))

def nostrip_comprehension(slist):
    return [s for s in slist if s]

def strip_filter(slist):
    return list(filter(str.strip, slist))

def strip_filter_map(slist): 
    return list(filter(None, map(str.strip, slist))) 

def strip_filter_comprehension(slist):  # waste memory
    return list(filter(None, [s.strip() for s in slist]))

def strip_filter_generator(slist):
    return list(filter(None, (s.strip() for s in slist)))

def strip_join_split(slist):  # words without(!) spaces
    return ' '.join(slist).split()

## Benchmarks
#
%timeit nostrip_filter(words)
142 µs ± 16.8 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)

%timeit nostrip_comprehension(words)
263 µs ± 19.1 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

%timeit strip_filter(words)
653 µs ± 37.5 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

%timeit strip_filter_map(words)
642 µs ± 36 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

%timeit strip_filter_comprehension(words)
693 µs ± 42.2 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

%timeit strip_filter_generator(words)
750 µs ± 28.6 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

%timeit strip_join_split(words)
796 µs ± 103 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

Per un elenco con una combinazione di spazi e valori vuoti, usa la semplice comprensione dell'elenco -

>>> s = ['I', 'am', 'a', '', 'great', ' ', '', '  ', 'person', '!!', 'Do', 'you', 'think', 'its', 'a', '', 'a', '', 'joke', '', ' ', '', '?', '', '', '', '?']

Quindi, puoi vedere, questo elenco ha una combinazione di spazi ed elementi null. Utilizzo dello snippet -

>>> d = [x for x in s if x.strip()]
>>> d
>>> d = ['I', 'am', 'a', 'great', 'person', '!!', 'Do', 'you', 'think', 'its', 'a', 'a', 'joke', '?', '?']