Entfernen Sie leere Zeichenfolgen aus einer Liste von Zeichenfolgen

Question 1

Ich möchte alle leeren Zeichenfolgen aus einer Liste von Zeichenfolgen in Python entfernen.

Meine Idee sieht so aus:

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

Gibt es einen pythonischeren Weg, dies zu tun?

Question 2

ich würde … benutzen 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 gibt einen Iterator von zurück filtersollte also in einen Aufruf von eingeschlossen werden list()

str_list = list(filter(None, str_list))

Question 3

Verwendung einer Listenverständnis ist der pythonischste Weg:

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

Wenn die Liste direkt geändert werden muss, weil es andere Referenzen gibt, die die aktualisierten Daten sehen müssen, verwenden Sie eine Slice-Zuweisung:

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

Question 4

Filter hat dafür tatsächlich eine spezielle Option:

filter(None, sequence)

Es filtert alle Elemente heraus, die mit False ausgewertet werden. Es ist nicht erforderlich, hier ein tatsächlich aufrufbares Element wie bool, len usw. zu verwenden.

Es ist genauso schnell wie map(bool, …)

Question 5

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

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

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

Zeit vergleichen

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

Beachte das filter(None, lstr) entfernt keine leeren Zeichenfolgen mit einem Leerzeichen ' 'es schneidet nur weg '' während ' '.join(lstr).split() entfernt beides.

Benutzen filter() Wenn Leerzeichen entfernt sind, dauert es viel länger:

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

Question 6

Die Antwort von @Ib33X ist großartig. Wenn Sie jede leere Zeichenfolge entfernen möchten, nachdem Sie sie entfernt haben. Sie müssen auch die Streifenmethode verwenden. Andernfalls wird auch der leere String zurückgegeben, wenn er Leerzeichen enthält. ” ” wird auch für diese Antwort gültig sein. So kann erreicht werden durch.

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

Die Antwort darauf wird sein ["first", "second"].

Wenn Sie verwenden möchten filter Methode stattdessen können Sie wie tun

list(filter(lambda item: item.strip(), strings)). Dies ergibt das gleiche Ergebnis.

Question 7

Fassen Sie die besten Antworten zusammen:

1. Leergut beseitigen OHNE Ausschalen:

Das heißt, Zeichenfolgen, die nur aus Leerzeichen bestehen, werden beibehalten:

slist = list(filter(None, slist))

PROs:

am einfachsten;
am schnellsten (siehe Benchmarks unten).

2. Zur Leergutbeseitigung nach dem Ausschalen …

2.a … wenn Zeichenfolgen KEINE Leerzeichen zwischen Wörtern enthalten:

slist=" ".join(slist).split()

PROs:

kleiner Code
schnell (ABER nicht am schnellsten bei großen Datensätzen aufgrund des Speichers, im Gegensatz zu den Ergebnissen von @paolo-melchiorre)

2.b … wenn Zeichenketten Leerzeichen zwischen Wörtern enthalten?

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

PROs:

am schnellsten;
Verständlichkeit des Codes.

Benchmarks auf einer 2018er Maschine:

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

Question 8

Anstelle von if x würde ich if X != ” verwenden, um nur leere Zeichenfolgen zu eliminieren. So was:

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

Dadurch wird der Datentyp None in Ihrer Liste beibehalten. Falls Ihre Liste ganze Zahlen enthält und 0 eine davon ist, wird sie ebenfalls beibehalten.

Zum Beispiel,

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