valor - return python español

eliminar el valor Ninguno de una lista sin eliminar el valor 0

Question

Esta fue mi fuente con la que comencé.

Mi lista

L = [0, 23, 234, 89, None, 0, 35, 9]

Cuando ejecuto esto:

L = filter(None, L)

Obtengo estos resultados

[23, 234, 89, 35, 9]

Pero esto no es lo que necesito, lo que realmente necesito es:

[0, 23, 234, 89, 0, 35, 9]

Porque estoy calculando el percentil de los datos y el 0 hace una gran diferencia.

¿Cómo eliminar el valor Ninguno de una lista sin eliminar el valor 0?

Answer 1

Diga que la lista es como a continuación

iterator = [None, 1, 2, 0, '''', None, False, {}, (), []]

Esto devolverá solo aquellos elementos cuyo bool(item) is True

print filter(lambda item: item, iterator)
# [1, 2]

Esto es equivalente a

print [item for item in iterator if item]

Para simplemente filtrar None:

print filter(lambda item: item is not None, iterator)
# [1, 2, 0, '''', False, {}, (), []]

Equivalente a:

print [item for item in iterator if item is not None]

Para obtener todos los elementos que evalúan False

print filter(lambda item: not item, iterator)
# Will print [None, '''', 0, None, False, {}, (), []]

Answer 2

Esta solución usa while en lugar de para :

value = None
while value in yourlist:
yourlist.remove(value)

Answer 3

FWIW, Python 3 hace que este problema sea fácil:

>>> L = [0, 23, 234, 89, None, 0, 35, 9]
>>> list(filter(None.__ne__, L))
[0, 23, 234, 89, 0, 35, 9]

En Python 2, utilizaría una lista de comprensión en su lugar:

>>> [x for x in L if x is not None]
[0, 23, 234, 89, 0, 35, 9]

Answer 4

La respuesta de @jamylak es bastante buena, sin embargo, si no quieres importar un par de módulos solo para hacer esta sencilla tarea, escribe tu propia lambda in situ:

>>> L = [0, 23, 234, 89, None, 0, 35, 9]
>>> filter(lambda v: v is not None, L)
[0, 23, 234, 89, 0, 35, 9]

Answer 5

Para Python 2.7 (ver respuesta de Raymond, para Python 3 equivalente):

Querer saber si algo "no es Ninguno" es tan común en python (y otros lenguajes OO), que en mi Common.py (que importo a cada módulo con "de importación común *"), incluyo estas líneas:

def exists(it):
return (it is not None)

Luego, para eliminar Ninguno elementos de una lista, simplemente hazlo:

filter(exists, L)

Encuentro esto más fácil de leer, que la comprensión de la lista correspondiente (que Raymond muestra, como su versión de Python 2).

Answer 6

Si se trata de una lista de listas, puede modificar la respuesta de sir @ Raymond

L = [ [None], [123], [None], [151] ] no_none_val = list(filter(None.__ne__, [x[0] for x in L] ) ) para python 2 sin embargo

no_none_val = [x[0] for x in L if x[0] is not None] """ Both returns [123, 151]"""

<< list_indice [0] para la variable en la lista si la variable no es ninguna >>

Answer 7

Usando la comprensión de la lista esto se puede hacer de la siguiente manera:

l = [i for i in my_list if i is not None]

El valor de l es:

[0, 23, 234, 89, 0, 35, 9]

Answer 8

Iteración vs espacio , el uso podría ser un problema. En situaciones diferentes, la creación de perfiles puede mostrar que es "más rápido" y / o requiere menos memoria.

# first
>>> L = [0, 23, 234, 89, None, 0, 35, 9, ...]
>>> [x for x in L if x is not None]
[0, 23, 234, 89, 0, 35, 9, ...]
# second
>>> L = [0, 23, 234, 89, None, 0, 35, 9]
>>> for i in range(L.count(None)): L.remove(None)
[0, 23, 234, 89, 0, 35, 9, ...]

El primer enfoque (como también lo sugirieron @jamylak , @Raymond Hettinger y @Dipto ) crea una lista duplicada en la memoria, lo que podría ser costoso para una lista grande con pocas entradas de None .

El segundo enfoque pasa por la lista una vez, y de nuevo cada vez hasta que se alcanza una None . Esto podría requerir menos memoria y la lista se irá reduciendo. La disminución en el tamaño de la lista podría tener una aceleración para muchas entradas de None en el frente, pero el peor de los casos sería si hubiera muchas entradas de None en la parte posterior.

La paralelización y las técnicas in situ son otros enfoques, pero cada uno tiene sus propias complicaciones en Python. Conociendo los datos y los casos de uso de tiempo de ejecución, así como el perfil del programa, es donde comenzar para operaciones intensivas o grandes datos.

La elección de cualquiera de estos enfoques probablemente no importará en situaciones comunes. Se vuelve más una preferencia de notación. De hecho, en esas circunstancias poco comunes, numpy o cython pueden ser alternativas cython lugar de intentar microgestionar las optimizaciones de Python.

Answer 9

>>> L = [0, 23, 234, 89, None, 0, 35, 9]
>>> [x for x in L if x is not None]
[0, 23, 234, 89, 0, 35, 9]

Solo por diversión, así es cómo puedes adaptar el filter para hacer esto sin usar un lambda (no recomendaría este código, solo para fines científicos)

>>> from operator import is_not
>>> from functools import partial
>>> L = [0, 23, 234, 89, None, 0, 35, 9]
>>> filter(partial(is_not, None), L)
[0, 23, 234, 89, 0, 35, 9]

Answer 10

from operator import is_not
from functools import partial
filter_null = partial(filter, partial(is_not, None))
# A test case
L = [1, None, 2, None, 3]
L = list(filter_null(L))