Je veux supprimer toutes les chaînes vides d'une liste de chaînes en python.

Mon idée ressemble à ceci:

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

Existe-t-il un moyen plus pythonique de le faire?

J'utiliserais 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 renvoie un itérateur de filter, devrait donc être encapsulé dans un appel àlist()

str_list = list(filter(None, str_list))

Utiliser une compréhension de liste est la manière la plus Pythonique:

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

Si la liste doit être modifiée sur place, car d'autres références doivent voir les données mises à jour, utilisez une affectation de tranche:

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

le filtre a en fait une option spéciale pour cela:

filter(None, sequence)

Il filtrera tous les éléments évalués comme faux. Pas besoin d'utiliser un véritable appelable ici comme bool, len et ainsi de suite.

C'est aussi rapide que la carte (bool, ...)

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

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

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

Comparez le temps

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

Notez que filter(None, lstr)cela ne supprime pas les chaînes vides avec un espace ' ', il ne taille ''que pendant qu'il ' '.join(lstr).split()supprime les deux.

Pour utiliser filter()avec les chaînes d'espaces supprimées, cela prend beaucoup plus de temps:

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

La réponse de @ Ib33X est géniale. Si vous souhaitez supprimer toutes les chaînes vides, après les avoir supprimées. vous devez également utiliser la méthode des bandes. Sinon, il renverra également la chaîne vide s'il contient des espaces blancs. Par exemple, "" sera également valable pour cette réponse. Donc, peut être atteint par.

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

La réponse sera ["first", "second"].
Si vous souhaitez utiliser la filterméthode à la place, vous pouvez faire comme
list(filter(lambda item: item.strip(), strings)). Cela donne le même résultat.

Au lieu de if x, j'utiliserais if X! = '' Afin d'éliminer simplement les chaînes vides. Comme ça:

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

Cela préservera le type de données Aucun dans votre liste. De plus, si votre liste contient des entiers et que 0 en fait partie, elle sera également conservée.

Par exemple,

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

Selon la taille de votre liste, cela peut être plus efficace si vous utilisez list.remove () plutôt que de créer une nouvelle liste:

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

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

Cela a l'avantage de ne pas créer une nouvelle liste, mais l'inconvénient d'avoir à chercher à chaque fois depuis le début, bien que contrairement à l'utilisation while '' in lcomme proposé ci-dessus, cela ne nécessite une recherche qu'une fois par occurrence de ''(il existe certainement un moyen de conserver le meilleur de les deux méthodes, mais c'est plus compliqué).

Gardez à l'esprit que si vous souhaitez conserver les espaces blancs dans une chaîne , vous pouvez les supprimer involontairement en utilisant certaines approches. Si vous avez cette liste

['bonjour le monde', '', '', 'bonjour'] ce que vous voudrez peut-être ['bonjour le monde', 'bonjour']

coupez d'abord la liste pour convertir tout type d'espace blanc en chaîne vide:

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

puis supprimez la chaîne vide de leur liste

space_clean_list = [x for x in space_to_empty if x]

Utilisation filter:

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

L'inconvénient de l'utilisation du filtre comme indiqué est qu'il est plus lent que les alternatives; aussi, lambdaest généralement coûteux.

Ou vous pouvez opter pour le plus simple et le plus itératif de tous:

# 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

c'est la plus intuitive des méthodes et elle le fait en temps décent.

Comme indiqué par Aziz Alto filter(None, lstr) ne supprime pas les chaînes vides avec un espace ' 'mais si vous êtes sûr que lstr ne contient que des chaînes, vous pouvez utiliserfilter(str.strip, lstr)

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

Comparer le temps sur mon 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

La solution la plus rapide pour supprimer ''et vider les chaînes avec un espace ' 'reste ' '.join(lstr).split().

Comme indiqué dans un commentaire, la situation est différente si vos chaînes contiennent des espaces.

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

Vous pouvez voir que filter(str.strip, lstr)conserver les chaînes avec des espaces, mais ' '.join(lstr).split()diviser ces chaînes.

Résumez les meilleures réponses:

1. Éliminez les vides SANS décapage:

Autrement dit, les chaînes de tous les espaces sont conservées:

slist = list(filter(None, slist))

Avantages:

• le plus simple;
• plus rapide (voir les repères ci-dessous).

2. Pour éliminer les vides après décapage ...

2.a ... lorsque les chaînes ne contiennent PAS d'espaces entre les mots:

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

Avantages:

• petit code
• rapide (MAIS pas plus rapide avec les grands ensembles de données en raison de la mémoire, contrairement aux résultats @ paolo-melchiorre)

2.b ... lorsque les chaînes contiennent des espaces entre les mots?

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

Avantages:

• le plus rapide;
• compréhensibilité du code.

Repères sur une machine 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)

Pour une liste avec une combinaison d'espaces et de valeurs vides, utilisez la compréhension de liste simple -

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

Donc, vous pouvez voir, cette liste a une combinaison d'espaces et d'éléments nuls. Utilisation de l'extrait -

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