Entfernen Sie leere Zeichenfolgen aus einer Liste von Zeichenfolgen

Question

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

Meine Idee sieht so aus:

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

Gibt es einen pythonischeren Weg, um dies zu tun?

Answer 1

Ich würde filter verwenden:

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)

In Python 3 gibt filter einen Iterator zurück, daher sollte er in einem Aufruf von list() eingehüllt werden

str_list = list(filter(None, str_list))

Answer 2

Die Verwendung eines Listen-Verständnisses 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, dann verwenden Sie eine Slice-Zuweisung:

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

Answer 3

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

filter(None, sequence)

Er wird alle Elemente filtern, die zu False ausgewertet werden. Es ist nicht nötig, hier einen tatsächlichen Aufruf wie bool, len und so weiter zu verwenden.

Es ist genauso schnell wie map(bool, ...)

Answer 4

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

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

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

Vergleiche Zeit

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

Beachten Sie, dass filter(None, lstr) keine leeren Zeichenfolgen mit einem Leerzeichen ' ' entfernt, es entfernt nur '', während ' '.join(lstr).split() beide entfernt.

Um filter() mit Leerzeichenzeichenfolgen entfernt zu verwenden, dauert es viel länger:

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

Answer 5

Fassen Sie die besten Antworten zusammen:

1. Entfernen von Leerelementen OHNE Entfernung:

D. h. alle Leerzeichen bleiben erhalten:

slist = list(filter(None, slist))

PROs:

• einfachste;
• schnellste (siehe Benchmarks unten).

2. Leerzeichen nach dem Entfernen eliminieren ...

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

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

PROs:

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

2.b ... wenn Zeichenfolgen Leerzeichen zwischen den Wörtern enthalten?

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

PROs:

• der schnellste;
• Verständlichkeit des Codes.

Benchmarks auf einem Computer aus dem Jahr 2018:

## Testdaten erstellen
#
import random, string
nwords = 10000
maxlen = 30
null_ratio = 0.1
rnd = random.Random(0)                  # deterministische Ergebnisse
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)
        ]

## Testfunktionen
#
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):  # verschwendet Speicher
    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):  # Wörter ohne(!) Leerzeichen
    return ' '.join(slist).split()

## Benchmarks
#
%timeit nostrip_filter(words)
142 µs ± 16.8 µs pro Schleife (Mittelwert ± Standardabweichung von 7 Durchläufen, 10000 Schleifen je Durchlauf)

%timeit nostrip_comprehension(words)
263 µs ± 19.1 µs pro Schleife (Mittelwert ± Standardabweichung von 7 Durchläufen, 1000 Schleifen je Durchlauf)

%timeit strip_filter(words)
653 µs ± 37.5 µs pro Schleife (Mittelwert ± Standardabweichung von 7 Durchläufen, 1000 Schleifen je Durchlauf)

%timeit strip_filter_map(words)
642 µs ± 36 µs pro Schleife (Mittelwert ± Standardabweichung von 7 Durchläufen, 1000 Schleifen je Durchlauf)

%timeit strip_filter_comprehension(words)
693 µs ± 42.2 µs pro Schleife (Mittelwert ± Standardabweichung von 7 Durchläufen, 1000 Schleifen je Durchlauf)

%timeit strip_filter_generator(words)
750 µs ± 28.6 µs pro Schleife (Mittelwert ± Standardabweichung von 7 Durchläufen, 1000 Schleifen je Durchlauf)

%timeit strip_join_split(words)
796 µs ± 103 µs pro Schleife (Mittelwert ± Standardabweichung von 7 Durchläufen, 1000 Schleifen je Durchlauf)