Eu quero remover todas as seqüências de caracteres vazias de uma lista de seqüências de caracteres em python.

Minha ideia é assim:

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

Existe alguma maneira mais pitônica de fazer isso?

Eu usaria 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 retorna um iterador de filter, portanto, deve ser agrupado em uma chamada paralist()

str_list = list(filter(None, str_list))

Usar uma compreensão de lista é a maneira mais pitônica:

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

Se a lista precisar ser modificada no local, porque existem outras referências que devem ver os dados atualizados, use uma atribuição de fatia:

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

filtro realmente tem uma opção especial para isso:

filter(None, sequence)

Ele filtrará todos os elementos que avaliarem como Falso. Não há necessidade de usar uma chamada real aqui, como bool, len e assim por diante.

É igualmente rápido como mapa (bool, ...)

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

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

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

Compare 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

Observe que filter(None, lstr)não remove seqüências de caracteres vazias com um espaço ' ', apenas remove-as ''enquanto ' '.join(lstr).split()remove as duas.

Para usar filter()com as cadeias de espaço em branco removidas, leva muito mais tempo:

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

A resposta de @ Ib33X is awesome. Se você deseja remover todas as cordas vazias, depois de retiradas. você precisa usar o método strip também. Caso contrário, ele retornará a sequência vazia também se tiver espaços em branco. Como "" também será válido para essa resposta. Então, pode ser alcançado por.

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

A resposta para isso será ["first", "second"].
Se você deseja usar o filtermétodo, pode fazer o mesmo
list(filter(lambda item: item.strip(), strings)). Este é o mesmo resultado.

Em vez de se x, eu usaria se X! = '' Para eliminar apenas cadeias vazias. Como isso:

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

Isso preservará Nenhum tipo de dados em sua lista. Além disso, caso sua lista tenha números inteiros e 0 seja um deles, ela também será preservada.

Por exemplo,

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

Dependendo do tamanho da sua lista, pode ser mais eficiente se você usar list.remove () em vez de criar uma nova lista:

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

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

Isso tem a vantagem de não criar uma nova lista, mas a desvantagem de ter que pesquisar desde o início de cada vez, embora, ao contrário do while '' in lque foi proposto acima, requer apenas uma pesquisa por ocorrência de ''(certamente existe uma maneira de manter o melhor ambos os métodos, mas é mais complicado).

Lembre-se de que, se você quiser manter os espaços em branco em uma string , remova-os sem querer usando algumas abordagens. Se você tem esta lista

['olá mundo', '', '', 'olá']] o que você pode querer ['olá mundo', 'olá']

primeiro apare a lista para converter qualquer tipo de espaço em branco em string vazia:

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

em seguida, remova a string vazia da lista deles

space_clean_list = [x for x in space_to_empty if x]

Use filter:

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

As desvantagens de usar o filtro, conforme apontado, é que ele é mais lento que as alternativas; Além disso, lambdageralmente é caro.

Ou você pode optar pelo mais simples e mais iterativo de todos:

# 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

esse é o método mais intuitivo e o faz em tempo decente.

Conforme relatado por Aziz Alto filter(None, lstr) , não remove cadeias vazias com um espaço, ' 'mas se você tiver certeza de que o lstr contém apenas cadeias, você pode usarfilter(str.strip, lstr)

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

Compare o tempo no meu 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

A solução mais rápida para remover ''e esvaziar cordas com um espaço ' 'permanece ' '.join(lstr).split().

Conforme relatado em um comentário, a situação será diferente se suas sequências contiverem espaços.

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

Você pode ver que filter(str.strip, lstr)preserva as strings com espaços, mas as ' '.join(lstr).split()dividirá.

Resuma as melhores respostas:

1. Eliminar vazios SEM remover:

Ou seja, as seqüências de todos os espaços são mantidas:

slist = list(filter(None, slist))

PROs:

• mais simples;
• mais rápido (veja os benchmarks abaixo).

2. Para eliminar vazios após a remoção ...

2.a ... quando as strings NÃO contêm espaços entre as palavras:

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

PROs:

• código pequeno
• rápido (mas não mais rápido com grandes conjuntos de dados devido à memória, ao contrário do que resulta em @ paolo-melchiorre)

2.b ... quando strings contêm espaços entre as palavras?

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

PROs:

• o mais rápido;
• compreensibilidade do código.

Benchmarks em uma máquina de 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)

Para uma lista com uma combinação de espaços e valores vazios, use a compreensão simples da lista -

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

Então, como você pode ver, esta lista possui uma combinação de espaços e elementos nulos. Usando o snippet -

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