Python String Length

Learn about Python string length: Discover how to use the len() function for efficient string manipulation, with examples and practical applications.

In Python, the length of a string refers to the number of characters it contains. Each character in a string, including spaces and special characters, is counted when determining the string's length.

String len() Syntax

Python provides a built-in function, len(), to find the length of a string. This function is straightforward and efficient, returning the number of characters in a given string.


length = len(string)


my_string = "Hello, Python!"
print(len(my_string))  # Output: 13

In this example, len(my_string) returns 13, which is the number of characters in the string "Hello, Python!".

Len() Function With Tuples And String

The len() function in Python is versatile and can be used to determine the length of various data types, including strings and tuples. While it returns the number of characters in a string, for tuples, it returns the number of elements present.

Len() With Strings

When applied to a string, len() counts and returns the total number of characters within the string. This count includes all characters, be they alphabetic, numeric, symbols, or whitespace.


example_string = "Hello World"
print(len(example_string))  # Output: 11

In this example, len(example_string) returns 11, which is the total number of characters in "Hello World".

Len() With Tuples

With tuples, len() functions differently. Instead of counting characters, it counts the number of elements (items) in the tuple. Each element, regardless of its data type or length, is counted as one.


example_tuple = ("Python", 3.9, "Programming", True)
print(len(example_tuple))  # Output: 4

Here, len(example_tuple) returns 4, indicating there are four elements in the tuple, regardless of their individual types or sizes.

Python len() TypeError

Encountering a TypeError when using the len() function in Python typically occurs when the function is applied to an object type that does not support length computation. The len() function is designed to work with objects that are sequences (like strings, lists, tuples) or collections (such as dictionaries, sets). When it is used with an unsupported type, Python raises a TypeError.

Common Scenario For TypeError

One common scenario where a TypeError might arise is when attempting to use len() on integer or float data types. Since these types are not sequences or collections, they do not have a length, and thus, using len() on them will result in an error.

number = 100
except TypeError as e:
    print(e)  # Output: object of type 'int' has no len()

In this example, len(number) causes a TypeError because number is an integer, not a sequence or collection.

Handling TypeError

To prevent TypeError, ensure that the len() function is only used with appropriate data types. If there is uncertainty about the type of an object, it can be checked using the isinstance() function before applying len().


if isinstance(number, (str, list, tuple, dict, set)):
    print("Object does not support length computation.")

This code checks if number is an instance of data types that support length computation before attempting to use len().

Python len() With Dictionaries And Sets

The len() function in Python is not only used for finding the length of strings but also works effectively with dictionaries and sets. When used with these data structures, len() returns the count of the number of items (key-value pairs in a dictionary and elements in a set).

len() With Dictionaries

In a dictionary, len() returns the number of key-value pairs. Each pair is counted as a single item regardless of the length of the key or the value.


my_dict = {'name': 'Alice', 'age': 30, 'city': 'New York'}
print(len(my_dict))  # Output: 3

Here, len(my_dict) returns 3, indicating there are three key-value pairs in the dictionary.

len() With Sets

For sets, len() counts the number of unique elements present in the set. It's important to note that sets do not allow duplicate elements.


my_set = {1, 2, 3, 4, 4, 5}
print(len(my_set))  # Output: 5

In this example, len(my_set) returns 5. Even though the number '4' appears twice in the set, it is only counted once because sets only store unique elements.

Python len() With Custom Objects

Using the len() function with custom objects in Python involves defining a __len__ method in the object's class. This special method allows Python's built-in len() function to return a custom length for instances of that class, making len() versatile beyond built-in data types.

Implementing __len__ In A Class

To use len() with a custom object, you need to implement the __len__ method in your class definition. This method should return an integer representing the length or size of the object as defined by your criteria.


class MyCollection:
    def __init__(self, items):
        self.items = items

    def __len__(self):
        return len(self.items)  # Custom length based on the number of items

my_obj = MyCollection([1, 2, 3, 4])
print(len(my_obj))  # Output: 4

In this example, MyCollection has a __len__ method that returns the length of its items attribute. When len(my_obj) is called, it invokes the custom __len__ method and returns the number of items in my_obj.

Use Cases For Custom __len__

Custom __len__ implementations are particularly useful in classes that encapsulate collections or complex data structures where the notion of 'length' or 'size' might be unique to the application's context.

Python len() With range()

Using the len() function with the range() function in Python allows you to iterate over a sequence of numbers corresponding to the length of a string. This combination is particularly useful when you need to perform operations on each character of a string based on its index.

Iterating Over String Length

When you combine len() with range(), you get a range object that spans from 0 to the length of the string minus one. This range is often used in for-loops to iterate over each character in the string by its index.


my_string = "Hello"
for i in range(len(my_string)):
    print(f"Character at position {i} is {my_string[i]}")

In this example, range(len(my_string)) creates a range from 0 to 4 (since the length of "Hello" is 5). The for-loop then iterates over each index, printing the character at that position in my_string.

You can also check these blogs:

  1. Reverse String In Python