Introduction

In Python, "emptying a list" can mean two slightly different things: remove all items from the existing list object, or make a variable refer to a new empty list. Those are not equivalent when other variables still reference the original list, so the right answer depends on how the list is shared.

The Most Direct In-Place Method

If you want to clear the existing list object, use clear():

items = [1, 2, 3]
items.clear()
print(items)  # []

This is the clearest modern Python solution. It mutates the list in place, which means any other reference to the same list sees the change too.

1items = [1, 2, 3]
2alias = items
3
4items.clear()
5
6print(items)  # []
7print(alias)  # []

That behavior is often exactly what you want.

Slice Deletion Does the Same Kind of Work

If you need an alternative that also empties the list in place, delete the full slice:

items = [1, 2, 3]
del items[:]
print(items)  # []

This is especially useful in older codebases or when you want to emphasize that the list object itself remains the same object after the operation.

You can see that with id():

1items = [1, 2, 3]
2before = id(items)
3
4del items[:]
5
6after = id(items)
7print(before == after)  # True

clear() has the same identity-preserving effect.

Reassignment Is Different

A common shortcut is:

items = [1, 2, 3]
items = []

This does not empty the existing list object. It only rebinds the variable items to a new empty list. Any aliases still point to the old one:

1items = [1, 2, 3]
2alias = items
3
4items = []
5
6print(items)  # []
7print(alias)  # [1, 2, 3]

That is not wrong. It is just a different operation.

Use reassignment when:

• you do not care about aliases
• you simply want the current variable to reference an empty list

Use clear() or del items[:] when:

• the original shared list object must be emptied in place
• other parts of the program hold references to that same list

Which Is Faster

For most application code, the performance difference is not the important part. The semantic difference is.

Conceptually:

• 'items.clear() removes elements from the existing list object'
• 'items = [] binds the name to a different list object'

Both are cheap enough for normal use. Choose based on reference behavior and readability, not micro-optimization.

A Practical Example with Function Arguments

The aliasing issue becomes clearer when a list is passed into a function:

1def reset_in_place(values):
2    values.clear()
3
4
5def rebind_local(values):
6    values = []
7
8
9data = [10, 20, 30]
10reset_in_place(data)
11print(data)  # []
12
13data = [10, 20, 30]
14rebind_local(data)
15print(data)  # [10, 20, 30]

reset_in_place() changes the caller's list because both names reference the same object. rebind_local() changes only the local parameter binding.

That distinction explains many "why did my list not clear?" bugs.

Less Useful Approaches

You may also see loops such as:

while items:
    items.pop()

This works, but it is usually worse than clear():

• more verbose
• less efficient in intent
• harder to read

A manual loop is only sensible if you need per-item processing while removing elements.

When the List Contains Large Objects

Emptying a list removes references from the list to its contents. If no other references to those objects remain, they become eligible for garbage collection.

That means clear() is also a useful memory-management signal in long-running programs. Just remember that clearing the list does not necessarily free memory immediately in a visible way. Python's allocator and garbage collector decide when underlying memory is reclaimed or reused.

Common Pitfalls

The most common mistake is using items = [] when the real goal was to clear a list shared by other references. In that case, aliases still point at the old populated list.

Another issue is overcomplicating the operation with pop() loops. They are noisier and usually unnecessary.

Developers also sometimes assume clear() returns the emptied list. It does not. Like many in-place list methods, it returns None.

Finally, if a list is used in multiple threads or shared across callbacks, clearing it in place may have side effects elsewhere. The semantics are simple, but the surrounding program may not be.

Summary

• Use list.clear() to empty a list in place.
• Use del items[:] when you want the same in-place behavior with slice syntax.
• Use items = [] only when rebinding the variable is acceptable.
• The key decision is whether other references to the original list must observe the change.
• Avoid manual pop() loops unless you need custom processing during removal.