Tôi muốn xóa tất cả các chuỗi trống khỏi danh sách các chuỗi trong python.

Ý tưởng của tôi trông như thế này:

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

Có cách nào pythonic hơn để làm điều này?

Tôi sẽ sử dụng 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 trả về một iterator từ đó filter, vì vậy nên được gọi trong một cuộc gọi đếnlist()

str_list = list(filter(None, str_list))

Sử dụng một sự hiểu biết danh sách là cách Pythonic nhất:

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

Nếu danh sách phải được sửa đổi tại chỗ, bởi vì có các tham chiếu khác phải xem dữ liệu được cập nhật, sau đó sử dụng phép gán lát:

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

bộ lọc thực sự có một tùy chọn đặc biệt cho việc này:

filter(None, sequence)

Nó sẽ lọc ra tất cả các yếu tố đánh giá thành Sai. Không cần phải sử dụng một cuộc gọi thực tế ở đây như bool, len và như vậy.

Nó cũng nhanh như bản đồ (bool, ...)

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

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

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

So sánh thời gian

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

Lưu ý rằng filter(None, lstr)không loại bỏ các chuỗi trống với một khoảng trắng ' ', nó chỉ cắt đi ''trong khi ' '.join(lstr).split()loại bỏ cả hai.

Để sử dụng filter()với các chuỗi khoảng trắng bị loại bỏ, phải mất nhiều thời gian hơn:

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

Trả lời từ @ Ib33X là tuyệt vời. Nếu bạn muốn loại bỏ mọi chuỗi trống, sau khi tước. bạn cần phải sử dụng phương pháp dải quá. Nếu không, nó cũng sẽ trả về chuỗi trống nếu nó có khoảng trắng. Giống như, "" cũng sẽ hợp lệ cho câu trả lời đó. Vì vậy, có thể đạt được bằng cách.

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

Câu trả lời cho điều này sẽ là ["first", "second"].
Nếu bạn muốn sử dụng filterphương pháp thay thế, bạn có thể làm như thế
list(filter(lambda item: item.strip(), strings)). Đây là kết quả tương tự.

Thay vì if x, tôi sẽ sử dụng if X! = '' Để loại bỏ các chuỗi trống. Như thế này:

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

Điều này sẽ bảo vệ Không có loại dữ liệu trong danh sách của bạn. Ngoài ra, trong trường hợp danh sách của bạn có số nguyên và 0 là một trong số đó, nó cũng sẽ được giữ nguyên.

Ví dụ,

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

Tùy thuộc vào kích thước danh sách của bạn, nó có thể hiệu quả nhất nếu bạn sử dụng list.remove () thay vì tạo danh sách mới:

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

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

Điều này có lợi thế là không tạo ra một danh sách mới, nhưng nhược điểm của việc phải tìm kiếm từ đầu mỗi lần, mặc dù không giống như sử dụng while '' in lnhư đề xuất ở trên, nó chỉ yêu cầu tìm kiếm một lần mỗi lần xuất hiện ''(chắc chắn có một cách để giữ tốt nhất cả hai phương pháp, nhưng nó phức tạp hơn).

Hãy nhớ rằng nếu bạn muốn giữ khoảng trắng trong một chuỗi , bạn có thể vô tình xóa chúng bằng cách sử dụng một số cách tiếp cận. Nếu bạn có danh sách này

['xin chào thế giới', '', '', 'xin chào'] những gì bạn có thể muốn ['xin chào thế giới', 'xin chào']

đầu tiên cắt danh sách để chuyển đổi bất kỳ loại khoảng trắng thành chuỗi trống:

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

sau đó loại bỏ chuỗi rỗng khỏi danh sách chúng

space_clean_list = [x for x in space_to_empty if x]

Sử dụng filter:

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

Hạn chế của việc sử dụng bộ lọc như đã chỉ ra là nó chậm hơn các lựa chọn thay thế; cũng thế,lambda thường là tốn kém.

Hoặc bạn có thể đi đơn giản nhất và lặp đi lặp lại nhiều nhất:

# 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

đây là phương pháp trực quan nhất và thực hiện nó trong thời gian tốt.

Theo báo cáo của Aziz Alto filter(None, lstr) không xóa chuỗi trống bằng dấu cách ' 'nhưng nếu bạn chắc chắn lstr chỉ chứa chuỗi bạn có thể sử dụngfilter(str.strip, lstr)

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

So sánh thời gian trên máy tính của tôi

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

Giải pháp nhanh nhất để loại bỏ ''và chuỗi trống với một khoảng trống ' 'vẫn còn ' '.join(lstr).split().

Như đã báo cáo trong một bình luận, tình huống sẽ khác nếu chuỗi của bạn chứa khoảng trắng.

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

Bạn có thể thấy rằng filter(str.strip, lstr)bảo tồn các chuỗi có khoảng trắng trên đó nhưng ' '.join(lstr).split()sẽ phân tách chuỗi này.

Tổng hợp các câu trả lời hay nhất:

1. Loại bỏ các emtpties mà không tước:

Đó là, tất cả các chuỗi không gian được giữ lại:

slist = list(filter(None, slist))

CHUYÊN NGHIỆP:

• đơn giản nhất;
• nhanh nhất (xem điểm chuẩn bên dưới).

2. Để loại bỏ trống sau khi tước ...

2.a ... khi các chuỗi KHÔNG chứa khoảng trắng giữa các từ:

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

CHUYÊN NGHIỆP:

• mã nhỏ
• nhanh (NHƯNG không nhanh nhất với các bộ dữ liệu lớn do bộ nhớ, trái với kết quả @ paolo-melchiorre)

2.b ... khi chuỗi chứa khoảng trắng giữa các từ?

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

CHUYÊN NGHIỆP:

• nhanh nhất;
• sự hiểu biết của mã.

Điểm chuẩn trên máy 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)

Đối với danh sách có sự kết hợp của khoảng trắng và giá trị trống, hãy sử dụng cách hiểu danh sách đơn giản -

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

Vì vậy, bạn có thể thấy, danh sách này có sự kết hợp của các khoảng trắng và các phần tử null. Sử dụng đoạn trích -

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