supprimer la valeur None d'une liste sans supprimer la valeur 0

C'était ma source avec laquelle j'ai commencé.

Ma liste

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

Quand je lance ceci:

L = filter(None, L)

J'obtiens ces résultats

[23, 234, 89, 35, 9]

Mais ce n'est pas ce dont j'ai besoin, ce dont j'ai vraiment besoin c'est:

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

Parce que je calcule le centile des données et le 0 fait beaucoup de différence.

Comment supprimer la valeur None d'une liste sans supprimer la valeur 0?

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

Juste pour le plaisir, voici comment vous pouvez vous y adapter filtersans utiliser de lambda, (je ne recommanderais pas ce code - c'est juste à des fins scientifiques)

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

FWIW, Python 3 facilite ce problème:

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

En Python 2, vous utiliseriez plutôt une compréhension de liste:

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

En utilisant la compréhension de la liste, cela peut être fait comme suit:

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

La valeur de l est:

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

Pour Python 2.7 (Voir la réponse de Raymond, pour l'équivalent Python 3):

Vouloir savoir si quelque chose "n'est pas None" est si courant en python (et dans d'autres langages OO), que dans mon Common.py (que j'importe dans chaque module avec "from Common import *"), j'inclus ces lignes:

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

Ensuite, pour supprimer les éléments None d'une liste, faites simplement:

filter(exists, L)

Je trouve cela plus facile à lire que la compréhension de la liste correspondante (que Raymond montre, comme sa version Python 2).

La réponse de @jamylak est assez agréable, cependant si vous ne voulez pas importer quelques modules juste pour faire cette tâche simple, écrivez votre propre lambdasur place:

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

Itération vs espace , l'utilisation pourrait être un problème. Dans différentes situations, le profilage peut s'avérer être "plus rapide" et / ou "moins gourmand en mémoire".

# 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, ...]

La première approche (comme le suggèrent également @jamylak , @Raymond Hettinger et @Dipto ) crée une liste en double en mémoire, ce qui pourrait être coûteux pour une grande liste avec peuNone entrées.

La deuxième approche parcourt la liste une fois, puis à chaque fois jusqu'à ce que a Nonesoit atteint. Cela pourrait être moins gourmand en mémoire et la liste se réduira au fur et à mesure. La diminution de la taille de la liste pourrait avoir une accélération pour de nombreuses Noneentrées à l'avant, mais le pire des cas serait si beaucoup deNone entrées étaient à l'arrière.

La parallélisation et les techniques sur place sont d'autres approches, mais chacune a ses propres complications en Python. Connaître les données et les cas d'utilisation d'exécution, ainsi que le profilage du programme sont où commencer pour des opérations intensives ou des données volumineuses.

Le choix de l'une ou l'autre approche n'aura probablement pas d'importance dans les situations courantes. Cela devient plus une préférence de notation. En fait, dans ces circonstances inhabituelles, numpyoucython peuvent être des alternatives valables au lieu de tenter de microgérer les optimisations Python.

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

S'il ne s'agit que d'une liste de listes, vous pouvez modifier la réponse de monsieur @ Raymond

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

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

<< list_indice [0] pour la variable dans la liste si la variable n'est pas Aucune >>

Dites que la liste est comme ci-dessous

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

Cela ne retournera que les articles dont bool(item) is True

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

Cela équivaut à

print [item for item in iterator if item]

Pour filtrer simplement Aucun:

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

Équivalent à:

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

Pour obtenir tous les éléments évalués comme faux

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