Chcę usunąć wszystkie puste ciągi z listy ciągów w pythonie.

Mój pomysł wygląda następująco:

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

Czy jest jakiś pythoniczny sposób na zrobienie tego?

Użyłbym 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 zwraca iterator filter, dlatego powinien być zawarty w wywołaniu dolist()

str_list = list(filter(None, str_list))

Korzystanie ze zrozumienia listy jest najbardziej pythonicznym sposobem:

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

Jeśli lista musi zostać zmodyfikowana w miejscu, ponieważ istnieją inne odwołania, które muszą zobaczyć zaktualizowane dane, użyj przypisania wycinka:

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

filtr ma do tego specjalną opcję:

filter(None, sequence)

Odfiltruje wszystkie elementy, które mają wartość False. Nie ma potrzeby używania tutaj rzeczywistego urządzenia do wywoływania, takiego jak bool, len i tak dalej.

Jest równie szybki jak mapa (bool, ...)

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

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

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

Porównaj czas

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

Zauważ, że filter(None, lstr)nie usuwa pustych ciągów ze spacją ' ', tylko przycina się ''podczas ' '.join(lstr).split()usuwania obu.

Aby użyć filter()z usuniętymi ciągami białych znaków, zajmuje to dużo więcej czasu:

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

Odpowiedź od @ Ib33X jest niesamowita. Jeśli chcesz usunąć każdy pusty ciąg, po usunięciu. musisz także użyć metody pasków. W przeciwnym razie zwróci również pusty ciąg, jeśli ma białe spacje. Podobnie „” będzie również ważne dla tej odpowiedzi. Można to osiągnąć przez.

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

Odpowiedź na to będzie ["first", "second"].
Jeśli filterzamiast tego chcesz użyć metody, możesz zrobić podobnie
list(filter(lambda item: item.strip(), strings)). To daje ten sam wynik.

Zamiast if x użyłbym if X! = '', Aby po prostu wyeliminować puste ciągi. Lubię to:

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

Pozwoli to zachować typ danych Brak na liście. Ponadto, jeśli twoja lista zawiera liczby całkowite, a 0 jest jedną z nich, również zostanie zachowana.

Na przykład,

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

W zależności od wielkości listy może być najbardziej wydajne, jeśli używasz list.remove () zamiast tworzyć nową listę:

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

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

Ma to tę zaletę, że nie tworzy nowej listy, ale ma tę wadę, że za każdym razem trzeba wyszukiwać od początku, chociaż w przeciwieństwie do korzystania z while '' in lpropozycji powyżej, wymaga ona wyszukiwania tylko raz dla każdego wystąpienia ''(z pewnością istnieje sposób, aby zachować najlepszą z obie metody, ale jest to bardziej skomplikowane).

Pamiętaj, że jeśli chcesz zachować białe spacje w ciągu , możesz je przypadkowo usunąć za pomocą niektórych metod. Jeśli masz tę listę

[„witaj świecie”, „”, „”, „witaj”] czego możesz chcieć [„witaj świecie”, „witaj”]

najpierw przytnij listę, aby przekonwertować dowolny biały znak na pusty ciąg znaków:

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

następnie usuń pusty ciąg z listy

space_clean_list = [x for x in space_to_empty if x]

Użyj filter:

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

Wady używania filtra, jak wskazano, polegają na tym, że jest on wolniejszy niż alternatywy; jest również lambdazwykle kosztowne.

Lub możesz wybrać najprostszą i najbardziej iteracyjną ze wszystkich:

# 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

jest to najbardziej intuicyjna metoda i robi to w przyzwoitym czasie.

Jak donosi Aziz Alto filter(None, lstr) , nie usuwa pustych łańcuchów ze spacją, ' 'ale jeśli jesteś pewien, że lstr zawiera tylko łańcuch, którego możesz użyćfilter(str.strip, lstr)

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

Porównaj czas na moim komputerze

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

Pozostaje najszybsze rozwiązanie do usuwania ''i opróżniania łańcuchów ze spacją .' '' '.join(lstr).split()

Jak podano w komentarzu, sytuacja wygląda inaczej, jeśli ciągi znaków zawierają spacje.

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

Możesz zobaczyć, że filter(str.strip, lstr)zachowaj ciągi ze spacjami, ale ' '.join(lstr).split()podzieli to ciągi.

Podsumuj najlepsze odpowiedzi:

1. Wyeliminuj opróżnienia BEZ usuwania:

Oznacza to, że zachowane są ciągi znaków spacji:

slist = list(filter(None, slist))

PRO:

• najprostszy;
• najszybszy (patrz testy porównawcze poniżej).

2. Aby wyeliminować opróżnienia po rozebraniu ...

2.a ... gdy ciągi NIE zawierają spacji między słowami:

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

PRO:

• mały kod
• szybki (ALE nie najszybszy z dużymi zestawami danych z powodu pamięci, w przeciwieństwie do wyników @ paolo-melchiorre)

2.b ... kiedy ciągi znaków zawierają spacje między wyrazami?

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

PRO:

• najszybszy;
• zrozumiałość kodu.

Testy porównawcze na maszynie 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)

Aby uzyskać listę z kombinacją spacji i pustych wartości, użyj prostego zrozumienia listy -

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

Widzisz więc, ta lista zawiera kombinację spacji i elementów zerowych. Korzystanie z fragmentu -

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