  Get free ebooK with 50 must do coding Question for Product Based Companies solved
Fill the details & get ebook over email  Thank You!
We have sent the Ebook on 50 Must Do Coding Questions for Product Based Companies Solved over your email. All the best!

# Len() Function in Python

Last Updated on October 18, 2023 by Ankit Kochar The len function in Python is a versatile and frequently used built-in function that provides a simple yet powerful way to determine the length or size of various data structures. Whether you’re working with strings, lists, tuples, dictionaries, or any other iterable object, the len() function allows you to quickly obtain the number of elements or characters within that data structure.

In this article, we’ll dive into the len function Python, exploring its functionality and applications across different data types. We’ll cover how to use len in Python effectively, its performance characteristics, and some common use cases in real-world Python programming. Understanding the len function in Python is fundamental for assessing the size and managing the contents of your data structures efficiently.

## What is Len Function in Python?

The len function in Python is a built-in function that returns the length of an object. It is commonly used to calculate the number of characters in a string, the number of elements in a list or tuple, or the number of key-value pairs in a dictionary.

Here is an example that demonstrates the use of len() function with strings:

```# Define a string variable
string_variable = "Hello PrepBytes!"

# Calculate the length of the string using len() function
length_of_string = len(string_variable)

# Print the length of the string
print("Length of string_variable is:", length_of_string)```

Output:

``Length of string_variable is: 16``

Explanation: In the example above, we first defined a string variable string_variable that contains the value "Hello PrepBytes!". We then used the len() function to calculate the length of the string and stored the result in the variable length_of_string. Finally, we printed the value of length_of_string to the console.

In this example, the len() function returns the number of characters in the string string_variable, which is 16. The len() function can be used with other objects as well, such as lists, tuples, and dictionaries, to calculate the number of elements or key-value pairs in the object.

### Syntax of Len Function in Python

In Python, the len() function is used to get the length (number of items) of a sequence or a collection such as a string, list, tuple, dictionary, or set.

The syntax for using the len() function is as follows:

``len(sequence)``

Here, the sequence can be any iterable object (i.e., an object that can be looped over).

### Parameters of Len Function in Python

The len function in Python takes a single parameter, which is the sequence or collection for which you want to get the length.

For example, to get the length of a list, you would use the following code:

```my_list = [1, 2, 'PrepBytes', 4, 5, False, 7]
list_length = len(my_list)
print(list_length)```

Output:

``7``

Explanation – In this example, the len() function returns the number of items in the my_list variable, which is 7.

### Return Value of Len Function in Python

The len function in Python returns an integer value that represents the number of items in the given sequence or collection.

For example, if you call len() on a string, it will return the number of characters in that string. If you call len() on a list, it will return the number of elements in that list.

## Examples of Len Function in Python

Here are some examples of using the len function in Python:

Example 1: Find the length of a nested list
Below is the code implementation and explanation of this example

```my_list = [[1, 2], [3, 4, 5], , [7, 8, 9, 10]]
total_elements = 0
for sublist in my_list:
total_elements += len(sublist)
print(total_elements)```

Output:

``10``

Explanation: In this example, we have a nested list with different lengths of sublists. To find the total number of elements in the list, we can use a for loop to iterate over each sublist and add the length of each sublist to a running total.

Example 2: Finding the length of a NumPy array
The len() function in Python can also be used with third-party libraries that implement their own sequence or collection data types.

```import numpy as pb

my_arr = pb.array([1, 2, 3, 4, 5])
arr_length = len(my_arr)
print(arr_length)```

Output:

``5``

Explanation: In this example, we use the NumPy library to create a NumPy array with five elements. We then call len() on the array, which returns the number of elements in the array (which is 5 in this case).

Example 3: Using len() function on User-Defined Classes
In Python, you can also use the len() function with user-defined classes by defining the len() method for your class. The len() method should return the number of elements or items in the class instance.

```class MyList:
def __init__(self, items):
self.items = items

def __len__(self):
return len(self.items)

my_list = MyList([1, 2, 3, 4, 5, 6, 7, 8, 9])
list_length = len(my_list)
print(list_length)```

Output:

``9``

Explanation: In this example, we create a MyList instance with nine items and call the len() function on the instance, which returns the number of items in the instance (which is 9 in this case).

By defining the len() method for your user-defined class, you can make instances of your class behave like sequences or collections in Python, allowing you to use them with built-in functions like len().

Example – 4 Using len() function with built-in Collections
The len() function in Python can be used with various built-in collections to get the number of elements or items in the collection.

```from collections import OrderedDict

my_dict = OrderedDict([('a', 1), ('b', 2), ('c', 3), ('d', 4), ('e', 5)])
dict_length = len(my_dict)
print(dict_length)```

Output:

``5``

Explanation: In this example, we use the OrderedDict() function from the collections module to create an ordered dictionary with five key-value pairs. We then call len() on the dictionary, which returns the number of key-value pairs in the dictionary (which is 5 in this case).

## Exceptions of Len Function in Python

Here are some of the exceptions that can be raised when using the len function in Python:

• TypeError: This exception is raised when the object passed to the len() function is not a sequence or collection data type, or does not support the len() method.
• AttributeError: This exception is raised when the object passed to the len() function does not have a len() method defined.
• NotImplementedError: This exception is raised when the len() method is not implemented for a user-defined class that is used with the len() function.
• OverflowError: This exception is raised when the result of calling len() on an object is too large to be represented by an integer. This can happen with very large lists.
• MemoryError: This exception is raised when there is not enough memory to complete the len() operation. This can happen when calling len() on a very large object.

It’s important to handle exceptions properly when using the len function in Python to ensure that your code is robust and does not crash unexpectedly.

Conclusion
The len function in Python is a fundamental tool for obtaining the size or length of various data structures, providing valuable insights into the contents of strings, lists, tuples, dictionaries, and more. Its simplicity and versatility make it an essential component of Python programming, aiding in tasks ranging from validating input to optimizing code performance.

In this article, we’ve explored the len() function’s capabilities and use cases, demonstrating its applicability in a variety of scenarios. Whether you’re working with collections of data or validating user inputs, len() is a powerful ally.

As you continue to develop Python applications, remember to leverage the len() function to assess the size and manage the contents of your data structures effectively. This knowledge will help you write more efficient and robust code.

## FAQs Related to Len in Python

Here are some frequently asked questions about using the len function in Python:

1. How does the len() function work in Python?
The len() function returns the number of items in an object. For strings, it counts the number of characters; for lists and tuples, it counts the number of elements; and for dictionaries, it counts the number of key-value pairs.

2. What data types can I use len() with in Python?
You can use len() with various data types, including strings, lists, tuples, dictionaries, sets, and other iterable objects.

3. Does the len() function work with custom objects or user-defined classes?
Yes, you can define your custom classes and implement the len() method to enable the use of len() with instances of those classes.

4. Is the len() function performance-efficient for all data types?
The performance of len() depends on the data type. For data types like strings and lists, it’s generally efficient and has a time complexity of O(1). However, for some custom classes, it may involve iterating through elements, resulting in O(n) complexity.

5. Can the len() function be used to check if a string or collection is empty?
Yes, you can use len() to check if a string or collection is empty. If len() returns 0, it indicates that the object is empty.

6. Are there alternative ways to find the length of a string or collection in Python?
While len() is the standard and recommended way to find the length, you can also use iterative approaches, such as for loops, to count elements manually. However, this is less efficient and not as readable as using len().