Python List Length: In Depth!

Calculating the length is a fundamental list operation. In Python list length is crucial when working with dynamic arrays that store ordered collections of items, whether built-in types like plain old integers, or strings, complex objects – or even other lists.

In this guide, we cover your basic usage, then take a look at some special cases and common gotchas, too.

Quick recap: What is a Python List?

A list in Python is an ordered, mutable collection of elements. It can contain any type of object, including integers, floats, strings, and even other lists. Lists are one of Python’s most flexible and widely used data structures.

Example:

my_list = [1, 2, 3, "apple", True]

In this example, my_list contains five elements of different types.

How to Calculate the Length of a Python List

To find the length of a list in Python, you can use the built-in len() function. This function returns the number of items (i.e., the length) in the list.

Syntax:

len(list)

• list: The list whose length you want to calculate.
• Return Value: The number of elements in the list (an integer).

Example:

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

In this example, the len() function returns 5 because my_list contains five elements.

Using len() with Empty Lists

When a list is empty (i.e., it contains no elements), the len() function returns 0.

Example:

empty_list = []
length = len(empty_list)
print(length)  # Output: 0

Here, empty_list has no items, so the length is 0.

Calculating Length of Nested Lists

Lists in Python can contain other lists as elements, forming nested lists (or multi-dimensional lists). The len() function, when applied to a nested list, only returns the number of top-level elements. It does not recursively count the number of elements in sublists.

Example:

nested_list = [[1, 2], [3, 4], [5, 6]]
length = len(nested_list)
print(length)  # Output: 3

In this example, nested_list contains three sublists, so len(nested_list) returns 3. It does not count the individual elements within each sublist.

If you want to calculate the total number of elements, including those in nested lists, you’ll need to use recursion or list comprehensions (which we’ll discuss later).

Use Cases for List Length Calculation

Knowing the length of a list is essential for various tasks in Python programming. Here are some common use cases:

1. Looping through Lists

When iterating over a list, you often need to know the list’s length to control the loop’s execution. The len() function helps you determine the number of iterations required.

Example:

my_list = [10, 20, 30, 40, 50]
for i in range(len(my_list)):
    print(my_list[i])

Output:

10
20
30
40
50

Here, the len() function determines how many times the loop should run.

2. Conditional Statements Based on Length

In many cases, you need to make decisions based on the length of a list. For instance, you might want to check if a list is empty before performing an operation.

Example:

my_list = []
if len(my_list) == 0:
    print("The list is empty.")
else:
    print("The list has elements.")

Output:

The list is empty.

Using len() allows you to write clean and concise conditionals that depend on the number of elements in a list.

3. Slicing and Subsetting Lists

You may want to extract a subset of a list based on its length. By combining len() with Python’s list slicing, you can achieve precise control over which parts of a list you’re working with.

Example:

my_list = [1, 2, 3, 4, 5]
half_length = len(my_list) // 2  # Integer division to get half the length
first_half = my_list[:half_length]
print(first_half)  # Output: [1, 2]

In this example, len(my_list) helps us find the midpoint of the list for slicing.

Advanced Techniques for Calculating Length in Special Cases

1. Calculating Total Length of Nested Lists

If you need to calculate the total number of elements in a nested list (including elements within sublists), a recursive function can help.

Example:

def total_length(nested_list):
    total = 0
    for item in nested_list:
        if isinstance(item, list):
            total += total_length(item)  # Recursive call
        else:
            total += 1
    return total

nested_list = [[1, 2], [3, 4], [5, [6, 7]]]
print(total_length(nested_list))  # Output: 7

In this example, the total_length() function calculates the number of all elements in the nested list.

2. Using List Comprehensions for Length Calculations

You can combine list comprehensions with len() to calculate specific lengths based on conditions.

Example:

my_list = [1, 2, 3, 4, 5, 6]
even_count = len([x for x in my_list if x % 2 == 0])
print(even_count)  # Output: 3

This example uses a list comprehension to count how many even numbers are in the list.

Performance Considerations with len()

The len() function in Python operates with O(1) time complexity. This means that calculating the length of a list is done in constant time, regardless of the list’s size. The length of a list is stored internally as part of the list’s metadata, so Python doesn’t have to count the elements each time you call len().

Example:

import time

large_list = list(range(1000000))

# Measure the time it takes to calculate the length
start_time = time.time()
print(len(large_list))  # Output: 1000000
print("Time taken:", time.time() - start_time)

Output:

1000000
Time taken: ~0.000001 seconds

Even for large lists, len() operates efficiently.

Best Practices for Working with List Lengths

1. Use len() Instead of Manually Counting Elements

Avoid manually iterating over a list to count its elements. The len() function is optimized and provides constant-time access to the list’s length.

Example:

# Avoid this
count = 0
for _ in my_list:
    count += 1

# Instead, use len()
count = len(my_list)

2. Avoid Using len() in Loop Conditions for Constant Lengths

If you know that the length of a list remains constant during a loop, calculate the length once before the loop rather than calling len() inside the loop.

Example:

# Bad practice: recalculating len() in each iteration
for i in range(len(my_list)):
    print(my_list[i])

# Better practice: calculate len() once
n = len(my_list)
for i in range(n):
    print(my_list[i])

3. Use len() for Empty List Checks

Instead of checking if a list is empty by comparing it directly to [], use if len(list) == 0: or simply if not list: to check if a list is empty.

Example:

# This works, but is unnecessary
if len(my_list) == 0:
    print("List is empty")

# More Pythonic way
if not my_list:
    print("List is empty")

Summary of Key Concepts

• len() is the primary function to calculate the length of a list in Python. It returns the number of elements in the list and operates with constant time complexity O(1).
• len() can be used to determine the length of lists, empty lists, and top-level elements in nested lists.
• For calculating the total length of nested lists, recursion or specialized methods like list comprehensions may be required.
• Use len() to control loops, slice lists, or perform conditional checks based on list size.
• Best practices include using len() efficiently by avoiding unnecessary calls and checking for empty lists in a concise, Pythonic way.

Exercises

1. Basic Length Calculation: Write a Python function that accepts a list and returns the length of the list using the len() function. Test it with lists of different sizes, including an empty list.
2. Nested List Length: Write a recursive function that calculates the total number of elements in a nested list, including sublists.
3. Conditional Slicing: Given a list, use the len() function to slice the list into two halves. If the list has an odd number of elements, ensure that the first half has one more element than the second half.

Check out our FREE Learn Python Programming Masterclass to hone your skills or learn from scratch.

The course covers everything from first principles to Graphical User Interfaces and Machine Learning

You can browse to the official Python documentation on lists here.

FAQ

Q1: Can I use len() on data types other than lists?

A1: Yes, the len() function works on many built-in data types in Python, including strings, tuples, dictionaries, sets, and more. It returns the number of elements or characters in these data types.

Example:

print(len("Hello"))  # Output: 5 (string)
print(len((1, 2, 3)))  # Output: 3 (tuple)
print(len({"a": 1, "b": 2}))  # Output: 2 (dictionary)
print(len({1, 2, 3}))  # Output: 3 (set)

Q2: Why does len() return a value even for empty lists?

A2: The len() function returns 0 for an empty list because the list exists, but it contains no elements. This is useful for checking whether a list is empty, allowing you to use len(my_list) == 0 or the more Pythonic if not my_list:.

Q3: How does len() handle lists with None values?

A3: len() counts every element in a list, including None values. It doesn’t differentiate between None and other elements; it simply counts the number of items present in the list.

Example:

my_list = [None, 1, 2, None]
print(len(my_list))  # Output: 4

Q4: Can I use len() with multidimensional lists (i.e., lists of lists)?

A4: Yes, len() returns the number of top-level elements in a multidimensional list, but it does not recursively count the elements inside nested lists. If you need to calculate the total number of elements across all sublists, you’ll need to use recursion or a custom function.

Example:

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

Q5: Does len() count all characters in a string, including spaces?

A5: Yes, the len() function counts every character in a string, including spaces, punctuation, and special characters.

Example:

my_string = "Hello, World!"
print(len(my_string))  # Output: 13 (including the space and punctuation)

Q6: Is there any difference in performance between using len() on small versus large lists?

A6: No, the len() function has O(1) time complexity, meaning it operates in constant time regardless of the size of the list. Python stores the length of the list internally, so calculating it does not depend on the number of elements in the list.

Q7: Can I store the result of len() in a variable and use it later?

A7: Yes, storing the result of len() in a variable is a common practice, especially when the length is used multiple times in a function or loop. This avoids repeatedly calling len() and keeps your code more readable.

Example:

my_list = [1, 2, 3, 4, 5]
length = len(my_list)

for i in range(length):
    print(my_list[i])

Q8: What happens if I call len() on an object that doesn’t support it?

A8: If you try to use len() on an object that doesn’t support it (e.g., an integer), Python will raise a TypeError. Only iterable objects like lists, strings, tuples, and dictionaries support the len() function.

Example:

try:
    print(len(10))  # Raises TypeError
except TypeError as e:
    print(e)  # Output: object of type 'int' has no len()

Q9: Can I change the length of a list manually?

A9: No, you can’t directly modify the length of a list using len(). To change the size of a list, you can add or remove elements using methods like append(), insert(), remove(), or slicing.

Example:

my_list = [1, 2, 3]
my_list.append(4)  # Adding an element increases the length
print(len(my_list))  # Output: 4

Q10: How do I find the length of each sublist in a nested list?

A10: You can use a loop or a list comprehension to calculate the length of each sublist inside a nested list.

Example:

nested_list = [[1, 2], [3, 4, 5], [6]]
lengths = [len(sublist) for sublist in nested_list]
print(lengths)  # Output: [2, 3, 1]

Q11: Can I use len() in lambda functions?

A11: Yes, you can use len() in lambda functions to calculate the length of an iterable. Lambda functions are anonymous functions in Python, and len() can be used within them as needed.

Example:

length_lambda = lambda x: len(x)
print(length_lambda([1, 2, 3]))  # Output: 3

Q12: Does len() work on generators or iterators?

A12: No, len() does not work on generators or iterators because they do not store all their elements in memory at once. Generators produce elements on the fly, so Python cannot determine their length. To calculate the length of a generator, you would need to exhaust it by converting it to a list or iterating through it.

Example:

gen = (x for x in range(10))
try:
    print(len(gen))  # Raises TypeError
except TypeError as e:
    print(e)  # Output: object of type 'generator' has no len()