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 eine pythonischere Möglichkeit, dies zu tun?

Ich würde verwenden 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 filterund sollte daher in einen Aufruf von eingeschlossen werdenlist()

str_list = list(filter(None, str_list))

Die Verwendung eines Listenverstä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, da andere Referenzen die aktualisierten Daten enthalten müssen, verwenden Sie eine Slice-Zuweisung:

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

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

filter(None, sequence)

Es werden alle Elemente herausgefiltert, die als falsch ausgewertet werden. Hier muss kein tatsächlicher Callable wie bool, len usw. verwendet werden.

Es ist genauso schnell wie eine Karte (bool, ...)

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

Beachten Sie, dass filter(None, lstr)leere Zeichenfolgen nicht mit einem Leerzeichen entfernt werden ' ', sondern nur entfernt werden, ''während ' '.join(lstr).split()beide entfernt werden.

Die Verwendung filter()mit entfernten Leerzeichenstrings dauert viel länger:

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

Die Antwort von @ Ib33X ist fantastisch. Wenn Sie jede leere Zeichenfolge nach dem Entfernen entfernen möchten. Sie müssen auch die Strip-Methode verwenden. Andernfalls wird auch die leere Zeichenfolge zurückgegeben, wenn Leerzeichen vorhanden sind. Wie "" gilt auch für diese Antwort. 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 filterstattdessen die Methode verwenden möchten , können Sie dies tun
list(filter(lambda item: item.strip(), strings)). Dies ergibt das gleiche Ergebnis.

Anstelle von if x würde ich if X! = '' Verwenden, um nur leere Zeichenfolgen zu entfernen. So was:

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

Dadurch bleibt der Datentyp "Keine" in Ihrer Liste erhalten. Falls Ihre Liste Ganzzahlen enthält und 0 eine davon ist, bleibt sie ebenfalls erhalten.

Zum Beispiel,

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

Abhängig von der Größe Ihrer Liste ist es möglicherweise am effizientesten, wenn Sie list.remove () verwenden, anstatt eine neue Liste zu erstellen:

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

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

Dies hat den Vorteil, dass keine neue Liste erstellt wird, aber den Nachteil, dass jedes Mal von Anfang an gesucht werden muss, obwohl im Gegensatz while '' in lzur oben vorgeschlagenen Verwendung nur einmal pro Auftreten von gesucht werden muss ''(es gibt sicherlich eine Möglichkeit, das Beste zu behalten beide Methoden, aber es ist komplizierter).

Beachten Sie, dass Sie die Leerzeichen in einer Zeichenfolge möglicherweise unbeabsichtigt entfernen, indem Sie einige Ansätze verwenden. Wenn Sie diese Liste haben

['Hallo Welt', '', '', 'Hallo'] was du willst ['Hallo Welt', 'Hallo']

Schneiden Sie zuerst die Liste, um eine beliebige Art von Leerzeichen in eine leere Zeichenfolge umzuwandeln:

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

Entfernen Sie dann die leere Zeichenfolge aus der Liste

space_clean_list = [x for x in space_to_empty if x]

Verwendung filter:

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

Die Nachteile der Verwendung von Filtern bestehen darin, dass sie langsamer als Alternativen sind. Auch lambdaist in der Regel teuer.

Oder Sie können sich für das einfachste und iterativste von allen entscheiden:

# 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

Dies ist die intuitivste der Methoden und wird in angemessener Zeit durchgeführt.

Wie von Aziz Alto berichtet filter(None, lstr), werden leere Zeichenfolgen nicht mit einem Leerzeichen entfernt. ' 'Wenn Sie jedoch sicher sind, dass lstr nur Zeichenfolgen enthält, können Sie diese verwendenfilter(str.strip, lstr)

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

Vergleiche die Zeit auf meinem 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

Die schnellste Lösung zum Entfernen ''und Leeren von Zeichenfolgen mit einem Leerzeichen ' 'bleibt bestehen ' '.join(lstr).split().

Wie in einem Kommentar berichtet, ist die Situation anders, wenn Ihre Zeichenfolgen Leerzeichen enthalten.

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

Sie können sehen, dass filter(str.strip, lstr)Zeichenfolgen mit Leerzeichen beibehalten ' '.join(lstr).split()werden, diese Zeichenfolgen jedoch aufgeteilt werden.

Fassen Sie die besten Antworten zusammen:

1. Beseitigen Sie Leergut OHNE Abisolieren:

Das heißt, All-Space-Zeichenfolgen bleiben erhalten:

slist = list(filter(None, slist))

PROs:

• am einfachsten;
• am schnellsten (siehe Benchmarks unten).

2. Um Leergut nach dem Abisolieren zu beseitigen ...

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 Datenmengen aufgrund des Speichers, im Gegensatz zu den Ergebnissen von @ paolo-melchiorre)

2.b ... wenn Strings Leerzeichen zwischen Wörtern enthalten?

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

PROs:

• am schnellsten;
• Verständlichkeit des Codes.

Benchmarks auf einer Maschine von 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)

Verwenden Sie für eine Liste mit einer Kombination aus Leerzeichen und leeren Werten das einfache Listenverständnis -

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

Sie sehen also, diese Liste enthält eine Kombination aus Leerzeichen und Nullelementen. Verwenden des Snippets -

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