Python len() Function

Spread the love

The len() function returns the number of items in an object. When the object is a string, len() returns the number of characters in the string. When the object is a data structure such as a list, tuple, or dictionary, len() returns the number of elements.


The syntax of the len() function is simple:



The len() function takes a single argument which can be

  • sequence – string, bytes, tuple, list
  • collection – dictionary, set, frozen set

Return Value:

len() function returns the number of items of an object.

How len( ) works with Various Data Types

Let’s dive into how len() interacts with different data types:


In the context of strings, len() counts the number of characters, including letters, digits, spaces, and punctuation marks.

greeting = "Hello, World!"
print(len(greeting))  # Output: 13


For lists, len() returns the number of elements in the list, regardless of the data types of the elements.

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


Tuples are similar to lists, but they are immutable. len() works the same way with tuples as it does with lists.

coordinates = (10, 20, 30)
print(len(coordinates))  # Output: 3


With dictionaries, len() returns the number of key-value pairs.

person = {"name": "Alice", "age": 25, "gender": "Female"}
print(len(person))  # Output: 3


Sets are unordered collections of unique elements, and len() tells us how many unique items are present.

basket = {"apple", "orange", "apple", "pear", "orange", "banana"}
print(len(basket))  # Output: 4 because 'apple' and 'orange' appear twice

The Internals of len( )

Python’s len() function is actually implemented in C, as it is a part of the Python/C API. This means it is very fast, making it preferable to manually counting items with a loop. When len() is called, Python internally calls the __len__() method of the object’s type.

Custom Objects and __len__( )

You can define a __len__() method in your own classes, which allows you to use len() on instances of these classes:

class CustomCollection:
    def __init__(self, data):
        self._data = data

    def __len__(self):
        return len(self._data)  # Assuming self._data is a list or similar

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

In this custom class, __len__() delegates to the len() of the data attribute, allowing the class to support the len() function naturally.

Error Handling with len( )

Trying to use len() on an object that doesn’t have a __len__() method will result in a TypeError:

number = 42
print(len(number))  # Raises TypeError: object of type 'int' has no len()

To handle such cases, you should ensure that len() is only used on objects that are known to be iterable or define a __len__() method.

Practical Uses of len( )

The len() function is not just for getting the size of a collection. Here are some practical uses:

Ensuring Minimum Length

For instance, you can check if a username meets a minimum length requirement:

username = "user1"
if len(username) < 6:
    print("Username must be at least 6 characters long.")

Empty vs. Non-Empty Validation

Checking if a list or string is empty:

items = []
if len(items) == 0:
    print("The list is empty.")

However, it’s more Pythonic to write it like this:

items = []
if not items:
    print("The list is empty.")

Data Analysis

len() can be instrumental in data analysis tasks, where you might need to know the number of observations or entries in a dataset:

data_points = [10, 20, 30, 15, 25, 35]
print("Number of data points:", len(data_points))

Slicing Sequences

When working with slices, you might use len() to calculate indices:

halfway_point = len(data_points) // 2
first_half = data_points[:halfway_point]
second_half = data_points[halfway_point:]


In conclusion, Python’s len() function is a powerful tool for determining the length or the number of elements in various data structures. Its simplicity belies its utility, as it works not only with built-in data types but also with custom objects that provide a __len__() method. From validating input to performing complex data manipulations, len() is truly a function that exemplifies Python’s philosophy of simple is better than complex.

Leave a Reply