python - index - Eliminar cadenas vacías de una lista de cadenas

string python

Question

Quiero eliminar todas las cadenas vacías de una lista de cadenas en python.

Mi idea se ve así:

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

¿Hay alguna forma más pitónica de hacer esto?

Answer 1

Dependiendo del tamaño de su lista, puede ser más eficiente si usa list.remove () en lugar de crear una nueva lista:

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

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

Esto tiene la ventaja de no crear una nueva lista, pero la desventaja de tener que buscar desde el principio cada vez, aunque a diferencia de while '''' in l como se propuso anteriormente, solo requiere buscar una vez por cada vez que aparece '''' (ciertamente hay una forma de mantener lo mejor de ambos métodos, pero es más complicado).

Answer 2

El filtro realmente tiene una opción especial para esto:

filter(None, sequence)

Filtrará todos los elementos que evalúen a Falso. No hay necesidad de usar un código real aquí, como bool, len, etc.

Es igual de rápido que el mapa (bool, ...)

Answer 3

En lugar de si x, utilizaría si X! = '''' Para eliminar cadenas vacías. Me gusta esto:

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

Esto conservará el tipo de datos Ninguno en su lista. Además, en caso de que su lista tenga enteros y 0 sea uno entre ellos, también se conservará.

Por ejemplo,

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

Answer 4

La respuesta de @ Ib33X es increíble. Si desea eliminar todas las cadenas vacías, despues de despojado. Necesitas usar el método de tira también. De lo contrario, también devolverá la cadena vacía si tiene espacios en blanco. Al igual que "" será válido también para esa respuesta. Por lo tanto, se puede lograr por.

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

La respuesta para esto será ["first", "second"] .
Si desea utilizar el método de filter , puede hacer lo siguiente:
list(filter(lambda item: item.strip(), strings)) . Esto es dar el mismo resultado.

Answer 5

Para eliminar los vacíos después del desmonte:

slist = map(lambda s: s and s.strip(), slist)
slist = filter(None, slist)

Algunos PROs:

• perezoso, basado en generadores, para ahorrar memoria;
• comprensibilidad decente del código;

• Rápido, de forma selectiva utilizando incorporaciones y comprensiones.

  def f1(slist):
      slist = [s and s.strip() for s in slist]
      return list(filter(None, slist))
  
  def f2(slist):
      slist = [s and s.strip() for s in slist]
      return [s for s in slist if s]
  
  
  def f3(slist):
      slist = map(lambda s: s and s.strip(), slist)
      return list(filter(None, slist))
  
  def f4(slist):
      slist = map(lambda s: s and s.strip(), slist)
      return [s for s in slist if s]
  
  %timeit f1(words)
  10000 loops, best of 3: 106 µs per loop
  
  %timeit f2(words)
  10000 loops, best of 3: 126 µs per loop
  
  %timeit f3(words)
  10000 loops, best of 3: 165 µs per loop
  
  %timeit f4(words)
  10000 loops, best of 3: 169 µs per loop

Answer 6

Recorra la lista de cadenas existentes y luego busque una cadena vacía, si no está vacía, complete una lista de cadenas nueva con los valores no vacíos y luego reemplace la lista de cadenas antigua con la lista de cadenas nuevas

Answer 7

Según lo informado por el filter(None, lstr) Aziz Alto filter(None, lstr) no elimina cadenas vacías con un espacio '' '' pero si está seguro de que lstr solo contiene cadenas, puede usar filter(str.strip, lstr)

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

Compara el tiempo en mi 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

La solución más rápida para eliminar '''' y vaciar cadenas con un espacio '' '' sigue siendo '' ''.join(lstr).split() .

Como se informó en un comentario, la situación es diferente si sus cadenas contienen espacios.

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

Puede ver que el filter(str.strip, lstr) conserva las cadenas con espacios en él, pero '' ''.join(lstr).split() dividirá estas cadenas.

Answer 8

Tenga en cuenta que si desea mantener los espacios en blanco dentro de una cadena , puede eliminarlos involuntariamente utilizando algunos métodos. Si tienes esta lista

[''hola mundo'', '''', '''', ''hola''] lo que pueda querer [''hola mundo'', ''hola'']

Primero recorte la lista para convertir cualquier tipo de espacio en blanco en una cadena vacía:

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

a continuación, elimine la cadena vacía de la lista de ellos

space_clean_list = [x for x in space_to_empty if x]

Answer 9

Utilizar filter :

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

Los inconvenientes de usar el filtro como se señaló es que es más lento que las alternativas; Además, lambda suele ser costosa.

O puede ir por el más simple y el más iterativo de todos:

# 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

Este es el método más intuitivo y lo hace en tiempo decente.

Answer 10

Yo usaría el filter :

str_list = filter(None, str_list) # fastest
str_list = filter(bool, str_list) # fastest
str_list = filter(len, str_list)  # a bit slower
str_list = filter(lambda item: item, str_list) # slower than list comprehension

Python 3 devuelve un iterador del filter , por lo que debe incluirse en una llamada a la list()

str_list = list(filter(None, str_list)) # fastest

( etc. )

Pruebas:

>>> timeit(''filter(None, str_list)'', ''str_list=["a"]*1000'', number=100000)
2.4797441959381104
>>> timeit(''filter(bool, str_list)'', ''str_list=["a"]*1000'', number=100000)
2.4788150787353516
>>> timeit(''filter(len, str_list)'', ''str_list=["a"]*1000'', number=100000)
5.2126238346099854
>>> timeit(''[x for x in str_list if x]'', ''str_list=["a"]*1000'', number=100000)
13.354584932327271
>>> timeit(''filter(lambda item: item, str_list)'', ''str_list=["a"]*1000'', number=100000)
17.427681922912598

Answer 11

Listar comprensiones

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

Salida: [''first'', ''second'']

Editar: Acortado como se sugiere

Answer 12

filter(None, str) no elimina las cadenas vacías con un espacio '''', solo las poda '''' y ''''.

join(str).split() elimina ambos. pero si el elemento de la lista tiene espacio, cambiará también los elementos de la lista porque primero une todos los elementos de la lista y luego los escupe por el espacio, por lo que debe usar:

str = [''hello'', '''', '' '', ''world'', '' '']
print filter(lambda x:x != '''', filter(lambda x:x != '' '', str))

Eliminará ambos y no afectará tus elementos también. Me gusta:

str = [''hello'', '''', '' '', ''world ram'', '' '']
print  '' ''.join(lstr).split()
print filter(lambda x:x != '''', filter(lambda x:x != '' '', lstr))

salida:-

[''hola'', ''mundo'', ''ram''] <-------------- salida de '' ''.join(lstr).split()
[''hola'', ''carnero del mundo'']

Answer 13

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

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

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

Comparar el tiempo

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

Tenga en cuenta que el filter(None, lstr) no elimina las cadenas vacías con un espacio '' '' , solo las poda '''' mientras que '' ''.join(lstr).split() elimina ambas.

Para usar el filter() con cadenas de espacios en blanco eliminadas, lleva mucho más tiempo:

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

Answer 14

str_list = [''2'', '''', ''2'', '''', ''2'', '''', ''2'', '''', ''2'', '''']

for item in str_list:
    if len(item) < 1:  
        str_list.remove(item)

Corto y dulce.