Python Tutorial



Python Tutorial

len() Function in Python


In this tutorial, we will deep-dive into the len function in Python, a versatile built-in utility. Essential for both beginners and seasoned developers, the len function in Python is instrumental in determining the size of various data structures, whether it's a simple string, a list, or more complex types. Let's unravel its functionalities and best practices.


The len function in Python stands out as a fundamental tool for measuring the length or size of multiple data types. Its applications span across strings, lists, tuples, and even dictionaries, marking its importance in day-to-day coding tasks and larger-scale projects.

What is len() Function in Python?

The len() function in Python is used to quickly determine the length or the number of items in a collection, such as a string, list, tuple, dictionary, or any other iterable object. It returns an integer representing the length of the given object. The len() function allows developers to make informed decisions and perform appropriate operations based on the size of the collections.

Syntax of len() Function in Python

Here is the syntax of len() function:


In the above syntax,

object: The collection or iterable object for which you want to determine the length.

How Do We Use the len() Function?

Let us learn how to use the len() function with the help of some examples.

Example 1: Using len() with Strings


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

In this example, len(text) returns 13, as there are 13 characters in the string "Hello, World!".

Example 2: Using len() with Lists


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

Here, len(my_list) returns 5, indicating that the list my_list contains 5 elements.

Example 3: Using len() with Tuples


my_tuple = (10, 20, 30, 40, 50)
length = len(my_tuple)
print(length)  # Output: 5

Similarly, len(my_tuple) returns 5, signifying that the tuple my_tuple consists of 5 elements.

Example 4: Using len() with Dictionaries


my_dict = {'a': 1, 'b': 2, 'c': 3}
length = len(my_dict)
print(length)  # Output: 3

In this case, len(my_dict) returns 3, which corresponds to the number of key-value pairs in the dictionary my_dict.

Exceptions of len() Function in Python

In most cases, len() is safe to use with built-in Python data structures, but when working with custom classes or non-iterable objects, you should handle potential exceptions or define the behavior using the __len__() method for custom classes. The len() function typically does not raise exceptions for built-in Python data structures like strings, lists, tuples, and dictionaries.

However, there are some scenarios where len() can raise exceptions:

  • Custom Objects: If you define your own custom classes, you can override the __len__() method to specify how the len() function behaves for instances of your class. If the __len__() method is not defined, calling len() on an instance of that class will raise a TypeError.


class MyCustomClass:
    def __init__(self): = [1, 2, 3]

obj = MyCustomClass()
length = len(obj)  # Raises TypeError: object of type 'MyCustomClass' has no len()

  • Other Non-Iterable Objects: len() is generally meant for iterable objects. If you attempt to use len() on non-iterable objects like integers or floats, it will raise a TypeError.


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

Examples of len() Function in Python 

Certainly, let's explore the usage of the len() function with various Python data structures, including built-in sequences, collections, other data types, third-party libraries, and user-defined classes, along with advanced code examples.

Using len() With Built-in Sequences (Lists, Tuples, Strings)

my_list = [1, 2, 3, 4, 5]
list_length = len(my_list)  # Returns 5

my_tuple = (10, 20, 30, 40, 50)
tuple_length = len(my_tuple)  # Returns 5

text = "Hello, World!"
string_length = len(text)  # Returns 13

Using len() Function with Built-in Collections (Dictionaries, Sets)

my_dict = {'a': 1, 'b': 2, 'c': 3}
dict_length = len(my_dict)  # Returns 3

my_set = {10, 20, 30, 40, 50}
set_length = len(my_set)  # Returns 5

Using len() Function with Other Built-in Data Types

number = 42
    length = len(number)  # Raises TypeError: object of type 'int' has no len()
except TypeError as e:
    print(f"Error: {e}")

Using the len() Function with Third-Party Libraries

# Using len() with NumPy arrays
import numpy as np

my_array = np.array([1, 2, 3, 4, 5])
array_length = len(my_array)  # Returns 5

# Using len() with Pandas DataFrames
import pandas as pd

data = {'Name': ['Alice', 'Bob', 'Charlie'], 'Age': [25, 30, 35]}
df = pd.DataFrame(data)
df_length = len(df)  # Returns 3 (number of rows)

Using len() Function on User-Defined Classes

class MyCustomClass:
    def __init__(self, data): = data

    def __len__(self):
        return len(

my_obj = MyCustomClass([1, 2, 3, 4, 5])
custom_length = len(my_obj)  # Returns 5 (custom implementation)

In this example, the MyCustomClass class defines a custom __len__() method, allowing the len() function to work with instances of this class.

Advanced Example of len() Function

Let's explore an advanced len() Python example by creating a program that calculates the length of sequences within a list and then performs customized operations based on those lengths. In this example, we'll use a list of words, and we'll categorize the words into different groups based on their lengths.


# Define a list of words
words = ["apple", "banana", "cherry", "date", "elderberry", "fig", "grape", "kiwi", "lemon", "mango"]

# Initialize empty dictionaries to categorize words by length
word_groups = {}

# Calculate the length of each word and categorize them
for word in words:
    length = len(word)

    # Check if a group for this length exists, create it if not
    if length not in word_groups:
        word_groups[length] = []

    # Append the word to its respective group

# Print the categorized words
for length, group in word_groups.items():
    if length == 1:
        print(f"Single-letter words: {', '.join(group)}")
        print(f"Words with length {length}: {', '.join(group)}")

In this program, we start with a list of words. We use the len() function to calculate the length of each word, and then we categorize the words into dictionaries based on their lengths. The keys in the word_groups dictionary represent word lengths, and the values are lists of words with those lengths.

We iterate through the list of words, and for each word, we calculate its length. If a group for that length does not yet exist in the word_groups dictionary, we create it. We then append the word to its respective group.

Finally, we print the categorized words. If the length is 1, we print them as single-letter words; otherwise, we display words grouped by their lengths.

Advantages of Using the len() Function

The len() function in Python offers several advantages when used in programming. These advantages contribute to code clarity, efficiency, and flexibility, making it a valuable tool in various scenarios.

Here are the key advantages of using the len() function:

  • Determine Length or Size: The primary purpose of len() is to calculate and return the length or size of a data structure or collection. This is particularly useful when working with sequences (strings, lists, tuples), collections (dictionaries, sets), and other iterable objects. It provides a quick and reliable way to know the number of elements or items in these structures.

  • Enhance Code Readability: Using len() in your code makes it more readable and self-explanatory. When you see len(obj) in the code, it immediately conveys that you're interested in the length or size of the object obj. This improves code clarity and reduces the need for comments or explanatory variable names.

  • Loop Iterations: The len() function is commonly used in loop iterations. It allows you to iterate through a sequence or collection while knowing the total number of items. This is crucial for tasks like indexing, slicing, or performing operations on each element.


my_list = [1, 2, 3, 4, 5]
for i in range(len(my_list)):
  • Conditional Statements: It simplifies conditional statements that depend on the length of a data structure. For instance, you can easily check if a list is empty using if len(my_list) == 0: or if a string is not empty using if len(text) > 0:.

  • Memory Efficiency: In some cases, len() can help optimize memory usage. For instance, you can preallocate arrays or lists with a specific size, knowing the length in advance, rather than dynamically resizing them.

  • Error Handling: When dealing with user input or external data sources, you can use len() to validate that the input has the expected length, helping prevent unexpected errors.

  • Performance Optimization: In cases where performance is critical, knowing the length of a collection can help optimize algorithms and data processing. For example, you can avoid unnecessary iterations or allocations.

  • Versatility: The len() function works with a wide range of Python data structures, including built-in types, third-party libraries, and user-defined classes. This versatility simplifies code that involves different types of objects.

  • Documentation and Debugging: When writing docstrings or comments, mentioning the expected length of inputs or outputs can be beneficial for developers who use your code. It serves as documentation and aids in debugging.


The len function in Python isn't just about counting characters or list items. It's about efficient code, optimizing operations, and enhancing readability. As we've journeyed through its varied applications and nuances, it's evident that mastering this function is key to solidifying one's Python foundations.

If you're looking to further elevate your Python prowess, consider the advanced courses offered by upGrad, ensuring you stay at the forefront of coding excellence.


  1. What is the difference between len() function in Python list and Python length of array?

The len() function works directly on lists to count items. However, for arrays, especially when using libraries like numPy, dimension specifics are essential.

  1. How to find length of string in Python without using len?

Iterative methods or specific string properties can be employed for this purpose.

  1. Is the len() function applicable within def in Python custom functions?

Yes, you can seamlessly integrate len() within user-defined functions for diverse functionalities.

  1. How does if len Python work in conditional checks?

The if len(Python_object) construct in Python checks if the specified object (like a list or string) has a non-zero length, executing the subsequent code block if true.

  1. Are there any performance concerns with len() for expansive data structures?

Typically, len() is efficient. However, for significantly large data structures, alternate optimization techniques might be more suitable.

Leave a Reply

Your email address will not be published. Required fields are marked *