What’s New ?

The Top 10 favtutor Features You Might Have Overlooked

Read More

Clear a List in Python: clear() and del statement

  • Sep 19, 2023
  • 6 Minute Read
  • Why Trust Us
    We uphold a strict editorial policy that emphasizes factual accuracy, relevance, and impartiality. Our content is crafted by top technical writers with deep knowledge in the fields of computer science and data science, ensuring each piece is meticulously reviewed by a team of seasoned editors to guarantee compliance with the highest standards in educational content creation and publishing.
  • By Abrar Ahmed
Clear a List in Python: clear() and del statement

We call Python a powerful programming language because it offers numerous ways to manipulate data structures. One common task when working with lists is to remove all elements from them, effectively emptying the list. In this article, we will explore different techniques to clear a list in Python, including the clear() method and the del statement.

How to Clear a List in Python?

To clear a list in Python, you have multiple options at your disposal. Let's explore some of the most commonly used methods.

1. Using the clear() Method

In Python, lists are objects that come with their own set of built-in methods. One such method is clear(), which removes all elements from a list, leaving it empty. Here's an example of how to use the clear() method:

my_list = [1, 2, 3, 4, 5]
print(my_list) # Output: []


As shown above, calling the clear() method on a list results in the removal of all its elements. The list becomes empty, indicated by the output of an empty pair of square brackets.

2. Assigning an Empty List

Another straightforward approach to clear a list is by assigning an empty list to the existing list variable. Here's an example:

my_list = [1, 2, 3, 4, 5]
my_list = []
print(my_list) # Output: []


In the above code snippet, we assign an empty list to the variable `my_list`, effectively clearing its contents. This technique creates a new list object and reassigns it to the variable, leaving the previous list for garbage collection.

3. Using the del Statement

In addition to the clear() method, Python provides the del statement, which can be used to delete objects, including list elements. When applied to a list, del removes all elements, resulting in an empty list. Consider the following example:

my_list = [1, 2, 3, 4, 5]
del my_list[:]
print(my_list) # Output: []


The del statement, followed by the slicing syntax `[:]`, removes all elements from the list, leaving it empty. This method modifies the existing list object rather than creating a new one.

Comparing clear() and del: Differences and Use Cases

While both the clear() method and the del statement can be used to clear a list, they have some fundamental differences. Understanding these differences will help you choose the most appropriate approach for your specific use case.

When you use clear(), the list object remains intact, albeit empty. This means that any references to the original list will still point to the same object. On the other hand, the del statement modifies the list object directly. Any references to the original list will reflect the changes made by del.

Consider the following code snippet:

my_list = [1, 2, 3, 4, 5]
new_list = my_list

print(new_list) # Output: []


In this example, we assign `my_list` to `new_list` before clearing `my_list` using the clear() method. As a result, `new_list` also becomes an empty list since both variables reference the same list object.

Contrastingly, when we use the del statement, the side effects differ:

my_list = [1, 2, 3, 4, 5]
new_list = my_list
del my_list[:]

print(new_list) # Output: [1, 2, 3, 4, 5]


Here, the `new_list` remains unchanged because the del statement modifies `my_list` directly without affecting other references.

Also, the clear() method and the del statement also differ in their memory management behaviors. When you use clear(), the list object itself remains in memory, but the memory allocated to store its elements is freed. This allows the list object to be reused without the need for reallocation.

On the other hand, the del statement completely removes all elements and the list object from memory. This means that the list object needs to be reallocated if you want to use it again.

Choosing between clear() and del depends on your specific requirements. If memory optimization is a concern, using clear() is more efficient since it avoids unnecessary reallocation. However, if you no longer need the list or if you want to reclaim memory, the del statement is a better choice.

Now you can learn how to remove duplicates from a list in Python.


In Python, clearing a list is a common task when working with data structures. This article provided an in-depth exploration of different techniques to empty a list, including using the clear() method and the del statement. 

FavTutor - 24x7 Live Coding Help from Expert Tutors!

About The Author
Abrar Ahmed
An ambivert individual with a thirst for knowledge and passion to achieve. Striving to connect Artificial Intelligence in all aspects of life. I am also an avid coder and partake in coding challenges all the time on Leetcode and CodeChef.