{"id":7084,"date":"2025-02-11T23:08:32","date_gmt":"2025-02-11T23:08:32","guid":{"rendered":"https:\/\/algocademy.com\/blog\/remove-none-from-list-in-python-a-comprehensive-guide\/"},"modified":"2026-10-15T10:34:50","modified_gmt":"2026-10-15T10:34:50","slug":"remove-none-from-list-in-python-a-comprehensive-guide","status":"publish","type":"post","link":"https:\/\/algocademy.com\/blog\/remove-none-from-list-in-python-a-comprehensive-guide\/","title":{"rendered":"Remove None from a List in Python: 6 Ways and When to Use Each"},"content":{"rendered":"

The short answer: use a list comprehension that tests is not None<\/code>.<\/p>\n

items = [1, None, 2, None, 3, 4, None, 5]\nclean = [x for x in items if x is not None]\nprint(clean)\n<\/code><\/pre>\n
[1, 2, 3, 4, 5]\n<\/code><\/pre>\n
That creates a new list and leaves items<\/code> unchanged. The rest of this post covers the cases where you want something different: changing the list in place, removing every “empty” value, handling nested data, and avoiding the two or three bugs that catch people out.<\/p>\n
Why is not None<\/code> and not != None<\/code><\/h2>\n
None<\/code> is a singleton: there is exactly one None<\/code> object in a Python program. The identity test x is None<\/code> asks “is this that object”, which is what you mean, and it cannot be fooled by a class that overrides ==<\/code>. PEP 8 recommends is<\/code> and is not<\/code> for comparisons with None<\/code>.<\/p>\n
The methods<\/h2>\n
1. List comprehension (default choice)<\/h3>\n
clean = [x for x in items if x is not None]\n<\/code><\/pre>\n
Readable, explicit about what is being removed, and fast. Use this unless you have a specific reason not to.<\/p>\n
2. filter(None, items)<\/code> (fastest, but read the warning)<\/h3>\n
clean = list(filter(None, items))\n<\/code><\/pre>\n
Passing None<\/code> as the function means “keep items that are truthy”. That removes None<\/code>, but also 0<\/code>, 0.0<\/code>, False<\/code>, empty strings and empty containers:<\/p>\n
mixed = [0, None, \"\", 1, False, [], 2, 0.0]\nprint(list(filter(None, mixed)))\nprint([x for x in mixed if x is not None])\n<\/code><\/pre>\n
[1, 2]\n[0, '', 1, False, [], 2, 0.0]\n<\/code><\/pre>\n
This is the most common bug with this idiom. If the list can contain zeros or empty strings that are valid data (prices, counts, optional text), use the comprehension. Use filter(None, ...)<\/code> only when you really want to drop every falsy value.<\/p>\n
3. filter()<\/code> with a lambda<\/h3>\n
clean = list(filter(lambda x: x is not None, items))\n<\/code><\/pre>\n
Correct, but slower than the comprehension because it calls a Python function for every element (see the timings below), and it is harder to read. There is no good reason to prefer it, except that it composes well if you already have a named predicate function to pass in.<\/p>\n
4. A plain for loop<\/h3>\n
clean = []\nfor x in items:\n    if x is not None:\n        clean.append(x)\n<\/code><\/pre>\n
Use it when the loop body does more than filtering, for example logging each skipped value or converting the kept ones.<\/p>\n
5. In place: slice assignment<\/h3>\n
If other code holds a reference to the same list and must see the change, rebinding a variable is not enough. Assign to the whole slice instead:<\/p>\n
a = [1, None, 2, None, 3]\nb = a                      # another reference to the same list\na[:] = [x for x in a if x is not None]\nprint(a, b)\n<\/code><\/pre>\n
[1, 2, 3] [1, 2, 3]\n<\/code><\/pre>\n
Compare with plain rebinding, where b<\/code> keeps the old contents:<\/p>\n
a = [1, None, 2]\nb = a\na = [x for x in a if x is not None]\nprint(a, b)\n<\/code><\/pre>\n
[1, 2] [1, None, 2]\n<\/code><\/pre>\n
This is the usual situation with function arguments and object attributes: a function that receives a list and is supposed to clean it for its caller has to use lst[:] = ...<\/code> (or return the new list and let the caller reassign).<\/p>\n
6. Repeated remove(None)<\/code> (avoid)<\/h3>\n
while None in items:\n    items.remove(None)\n<\/code><\/pre>\n
It works, and it modifies the list in place, but each None in items<\/code> check and each remove<\/code> scans the list from the start. With k<\/em> Nones in a list of n<\/em> items that is roughly n × k<\/em> work, so it gets slow quickly. The timings below show how slow.<\/p>\n
Timings<\/h2>\n
I measured each approach on a list of 100,000 integers where every tenth element is None<\/code>, using Python 3.12 and averaging 20 runs (your numbers will differ, the ratios are what matter):<\/p>\n\n\n\n\n\n\n\n\n\n\n\n
Method<\/th>\nTime<\/th>\n<\/tr>\n<\/thead>\n
filter(None, items)<\/code><\/td>\n0.70 ms<\/td>\n<\/tr>\n
List comprehension<\/td>\n1.05 ms<\/td>\n<\/tr>\n
For loop with append<\/code><\/td>\n1.31 ms<\/td>\n<\/tr>\n
Slice assignment from a comprehension (on a copy)<\/td>\n1.76 ms<\/td>\n<\/tr>\n
filter<\/code> with a lambda<\/td>\n3.35 ms<\/td>\n<\/tr>\n
itertools.filterfalse<\/code> with a lambda<\/td>\n3.14 ms<\/td>\n<\/tr>\n
for _ in range(items.count(None)): items.remove(None)<\/code><\/td>\n3,413 ms<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
The remove<\/code> approach is more than 3,000 times slower on this input. On a 20,000-item list, the while None in ...<\/code> loop took about 270 ms against 0.21 ms for the comprehension. For lists of a few dozen items none of this matters, so choose for readability; but the gap is why remove<\/code> in a loop is worth avoiding.<\/p>\n
Common mistakes<\/h2>\n
Removing while iterating<\/h3>\n
bad = [None, None, 1, None]\nfor x in bad:\n    if x is None:\n        bad.remove(x)\nprint(bad)\n<\/code><\/pre>\n
[1, None]\n<\/code><\/pre>\n
Two None<\/code> values are still there. When you remove an element, the items after it shift left, and the loop’s internal index then skips the element that moved into the removed slot. Never change a list’s length while looping over it. Build a new list (comprehension) or loop over a copy.<\/p>\n
Forgetting that filter<\/code> returns an iterator<\/h3>\n
In Python 3, filter(...)<\/code> returns a lazy iterator, not a list. len(filter(None, items))<\/code> raises a TypeError<\/code>, and iterating it twice gives nothing the second time. Wrap it in list()<\/code> if you need a list.<\/p>\n
Treating NaN like None<\/h3>\n
A missing value from NumPy or pandas is often float('nan')<\/code>, not None<\/code>, and nan<\/code> is not None<\/code>:<\/p>\n
import math\nnan = float(\"nan\")\nprint([x for x in [1.0, nan, 2.0] if x is not None])\nprint([x for x in [1.0, nan, 2.0] if not math.isnan(x)])\n<\/code><\/pre>\n
[1.0, nan, 2.0]\n[1.0, 2.0]\n<\/code><\/pre>\n
(math.isnan<\/code> only works on numbers, so use it when the list is numeric.)<\/p>\n
Dropping None and misaligning parallel lists<\/h3>\n
If you have two lists matched by position, removing None<\/code> from only one breaks the pairing. Filter them together:<\/p>\n
names = [\"a\", \"b\", \"c\"]\nvals = [1, None, 3]\nprint([(n, v) for n, v in zip(names, vals) if v is not None])\n<\/code><\/pre>\n
[('a', 1), ('c', 3)]\n<\/code><\/pre>\n
Other situations<\/h2>\n
Nested lists<\/h3>\n
A flat comprehension only looks at the top level. For arbitrarily nested lists, recurse:<\/p>\n
def strip_none(v):\n    if isinstance(v, list):\n        return [strip_none(x) for x in v if x is not None]\n    return v\n\nprint(strip_none([1, [2, None, 3], [4, [5, None]], None, 6]))\n<\/code><\/pre>\n
[1, [2, 3], [4, [5]], 6]\n<\/code><\/pre>\n
This only descends into lists. If your data can contain tuples or dicts, add cases for them.<\/p>\n
Dictionaries<\/h3>\n
d = {\"a\": 1, \"b\": None, \"c\": 0}\nprint({k: v for k, v in d.items() if v is not None})\n<\/code><\/pre>\n
{'a': 1, 'c': 0}\n<\/code><\/pre>\n
Replace instead of remove<\/h3>\n
Sometimes the position matters and you want a default instead of deleting the item:<\/p>\n
print([0 if x is None else x for x in items])\n<\/code><\/pre>\n
[1, 0, 2, 0, 3, 4, 0, 5]\n<\/code><\/pre>\n
Just computing something from the values<\/h3>\n
You do not always need a cleaned list. A generator expression skips the Nones without building anything:<\/p>\n
print(sum(x for x in items if x is not None))\n<\/code><\/pre>\n
15<\/code><\/pre>\n
This is often why the question comes up: sum([1, None])<\/code> and sorted([3, None, 1])<\/code> both raise TypeError<\/code>, because Python cannot add or compare None<\/code> with a number.<\/p>\n
pandas<\/h3>\n
For a pandas Series or DataFrame, use dropna()<\/code> rather than converting to a list: pd.Series([1, None, 3]).dropna()<\/code> keeps the values 1.0<\/code> and 3.0<\/code> (the integers become floats because pandas stores the missing value as NaN).<\/p>\n
Which one should you use?<\/h2>\n