How to Check the Length of List in Python

Python, a widely utilized and versatile programming language, provides built-in functions and methods for everyday tasks. One fundamental operation is to check the length of the list. Python simplifies counting the elements within a list to ensure a good data management and data manipulation. This tutorial covers a variety of methods to figure out how long a list is in Python. We’ll provide a comprehensive explanation of each method and its useful uses.

Example 1: Using the Built-In Len() Function

Determining the list length in Python is a fundamental and frequently used operation in programming. It’s crucial to understand the various methods to achieve this as it can significantly impact the efficiency and readability of our code. In this example, we’ll explore the several techniques to check the length of a list in Python, providing clear explanations and examples of each approach. The most straightforward and widely used method to check the length of a list is utilizing Python’s built-in len() function. This function is not only efficient, but it is also highly readable. For the majority of Python developers, it is an excellent option because it returns the number of entries in the provided list.

Here’s the code for this illustration:

# Initialize list
my_list = [1, 2, 3, 4, 5]
#Applying len method
length = len(my_list)
#Using Print statement
print("The length of the list is:", length)

The code has a list named “my_list” that contains five integers. We apply the len() function to “my_list” and the result, which is the count of elements in the list, is stored in the “length” variable. The last print() statement displays the length of a list. This straightforward method of using the len() function is precise and highly efficient, making it the preferred choice for most applications.

Example 2: Iterating through the List

Another method to determine the length of a list involves manually iterating through the list. This method could not be as accurate as using len(); this approach allows for more flexibility. It is beneficial when performing additional operations while counting the elements. The following is the code for this example:

my_list = [10, 20, 30, 40, 50]
count = 0
for item in my_list:
    count += 1
print("The length of the list is:", count)

In this code snippet, we initialize a “count” variable and iterate through each element in “my_list”. For each element, we increment the “count” by one. This loop continues until all elements in the list are processed which results in an accurate count of the list’s length.

This approach requires more expansion than using len(); it allows us to include additional logic or conditions during the iteration.

Example 3: Using a “While” Loop

We may also determine the length of a list by utilizing a “while” loop. This method is less common but is an alternative to iterate through a list using a “for” loop. Here’s an illustration:

my_list = ['apple', 'banana', 'cherry', 'date']
count = 0
index = 0
while index < len(my_list):
    count += 1
    index += 1
print("The length of the list is:", count)

In this code, we initialize two variables: “count” to store the count of elements and “index” to keep track of the current index. We use a “while” loop to iterate through the list until the “index” becomes equal to the length of “my_list”. The “count” is incremented during each iteration, and the “index” is also increased to advanced value. Finally, the list length is displayed using the print() statement.

While this method accomplishes the task, it’s less correct in Python, and using a “for” loop or the len() function is generally preferred for simplicity and better readability.

Example 4: Using List Comprehensions

List operations can be carried out much more accurately and effectively with list comprehension. While they are often used for creating new lists, we can also utilize them to count the elements in a list.

The code for this specific example is given as follows:

my_list = [7, 14, 21, 28, 35]
count = len([item for item in my_list])
print("The length of the list is:", count)

This code creates a list comprehension that iterates through each item in “my_list”. The comprehension itself doesn’t perform any specific operation on the items. All it does is list every item in the updated list. The result is a new list with elements that are similar to “my_list”. We then use the len() function to count the elements in this new list which is essentially the length of the original list.

This precise approach achieves the desired outcome in a single line of code.

Example 5: Using the Enumerate() Function

Python’s enumerate() function is a versatile tool that allows us to iterate over the elements and their indices in a list. We can use it to count the elements in the list while having access to their positions. Here comes an example:

my_list = ['red', 'green', 'blue', 'yellow']
count = 0
for index, item in enumerate(my_list):
    count += 1
print("The length of the list is:", count)

In this code, we initialize the “count” variable to keep track of several elements. We iterate over the “my_list” using a “for” loop and the enumerate() function. The enumerate() function provides both the “index” and “item” (element) during each iteration. To properly count the elements, we increase the {count} for each element by one.

This approach is beneficial when we need to know the index of elements within the list while counting them. However, counting alone expands more than using the len() function.

Example 6: Using a User-Defined Function

To know the logic of finding the length of a list in a custom function, we can create a user-defined function. This approach enhances reusability in our code.

Here’s an example of the code:

def get_list_length(lst):
    count = 0
    for item in lst:
        count += 1
    return count

my_list = ['A', 'B', 'C', 'D', 'E']
length = get_list_length(my_list)
print("The length of the list is:", length)

In this code, we define a function called “get_list_length” which accepts an “lst” list as a parameter. The function iterates through each entry in the input list after initializing the variable {count} to zero. For each element, we increment the “count” by one. Finally, the function returns the count as the length of the list.

The primary advantage of using a user-defined function is reusability. We can call this function with different lists throughout our code, making it a practical choice for scenarios where we need to count the elements of multiple lists.


The various methods that are discussed in this article provide a toolkit for counting the elements in a list from different angles. Because of its adaptability, we can choose the best strategy for our coding goals and work environment. Whether we want efficiency, readability, or specific features like index tracking, Python offers a solution for all our list-length checking needs.

About the author

Omar Farooq

Hello Readers, I am Omar and I have been writing technical articles from last decade. You can check out my writing pieces.