Skip to main content

Python Pandas: How to Find Length of Longest String in DataFrame Column

Determining the length of the longest string within a Pandas DataFrame column is often necessary for tasks like data validation (ensuring strings don't exceed a maximum length), schema definition for databases, or optimizing display widths. Pandas provides efficient vectorized string methods to achieve this.

This guide explains how to find the length of the longest string in a specific DataFrame column, retrieve the string itself, and extend this to find maximum lengths across multiple columns.

The Goal: Measuring Maximum String Length​

Given a Pandas DataFrame with one or more columns containing string data, we want to find:

  • The maximum character length among all strings in a specific column.
  • The actual string(s) that have this maximum length.
  • The index of such a string.
  • The maximum string length for each string-like column in the entire DataFrame.

Example DataFrame​

import pandas as pd
import numpy as np # For vectorized example

data = {
    'ProductID': ['A101-X', 'B202-YZ', 'C303-WXYZ', 'D404', 'E505-V'],
    'Description': [
        'A standard widget for all basic needs.',
        'Premium gadget with advanced features and extended warranty.',
        'Compact and efficient.',
        'Entry-level item, budget-friendly option for everyone.',
        'Heavy-duty industrial version with extra strength.'
    ],
    'Category': ['Widgets', 'Gadgets', 'Gizmos', 'Items', 'Industrial'],
    'NumericCol': [10, 20, 15, 25, 30] # Non-string column for later example
}

df = pd.DataFrame(data)
print("Original DataFrame:")
print(df)

Output:

Original DataFrame:
   ProductID                                        Description    Category  \
0     A101-X             A standard widget for all basic needs.     Widgets   
1    B202-YZ  Premium gadget with advanced features and exte...     Gadgets   
2  C303-WXYZ                             Compact and efficient.      Gizmos   
3       D404  Entry-level item, budget-friendly option for e...       Items   
4     E505-V  Heavy-duty industrial version with extra stren...  Industrial   

   NumericCol  
0          10  
1          20  
2          15  
3          25  
4          30

Finding Length of Longest String in a SINGLE Column​

This is the most idiomatic and efficient Pandas way:

  1. Select the column: df['YourColumn'].
  2. Use the .str accessor to apply string methods.
  3. Call .len() to get a Series of lengths for each string.
  4. Call .max() on this Series of lengths.
import pandas as pd

df_example = pd.DataFrame({
    'ProductID': ['A101-X', 'B202-YZ', 'C303-WXYZ'],
    'Description': ['Short desc.', 'Medium length description.', 'A very, very long description.']
})

# Find max length in 'ProductID' column
max_len_product_id = df_example['ProductID'].str.len().max()
print(f"Max length of strings in 'ProductID': {max_len_product_id}")

# Find max length in 'Description' column
# df_example['Description'].str.len() would give: Series([11, 26, 30])
max_len_description = df_example['Description'].str.len().max()
print(f"Max length of strings in 'Description': {max_len_description}")

Output:

Max length of strings in 'ProductID': 9
Max length of strings in 'Description': 30
note
  • Series.str.len(): Returns a Series containing the length of each string. NaN values in the original Series will result in NaN in the length Series.
  • Series.max(): Returns the maximum value from the Series of lengths, ignoring NaNs by default.

Using Series.map(len).max()​

You can also use the map() method to apply Python's built-in len() function to each string in the Series.

import pandas as pd

df_example = pd.DataFrame({
    'ProductID': ['A101-X', 'B202-YZ', 'C303-WXYZ'],
})

# Using map(len)
max_len_product_id_map = df_example['ProductID'].map(len).max()
# df_example['ProductID'].map(str).map(len).max() if column might not be string type
print(f"Max length in 'ProductID' (using map): {max_len_product_id_map}")

Output:

Max length in 'ProductID' (using map): 9
  • df['Column'].map(len): Applies len() to each element. This will raise a TypeError if the column contains non-string data (like numbers or NaN). It's safer to ensure the column is string type first (e.g., df['Column'].astype(str).map(len).max()) if dealing with mixed types.
  • .str.len() is generally preferred as it's designed for Pandas Series and handles NaNs more gracefully.

Retrieving the ACTUAL Longest String(s) in a Column​

Using Python's max(series, key=len)​

Python's built-in max() function can take a key argument. When key=len is provided, max() iterates through the Series and returns the string element that has the maximum length.

import pandas as pd

df_example = pd.DataFrame({
    'Description': ['Short.', 'Medium length.', 'A very, very, very long description indeed!']
})

# ✅ Get the actual longest string
longest_description_str = max(df_example['Description'].dropna(), key=len) # dropna() if NaNs might be present
print(f"The longest string in 'Description' is: '{longest_description_str}'")

Output:

The longest string in 'Description' is: 'A very, very, very long description indeed!'
note
  • df['Description'].dropna(): It's good practice to use .dropna() if your Series might contain NaN values, as len(np.nan) would raise an error.
  • If there are multiple strings with the same maximum length, max(..., key=len) returns the first one encountered. To get all, you'd first find the max length (Method 3.1) and then filter: 
    max_l = df['Description'].str.len().max()
    longest_strings_all = df['Description'][df['Description'].str.len() == max_l]
    print(longest_strings_all)

Getting the Index of the Longest String​

Using Series.str.len().idxmax()​

The Series.idxmax() method returns the index label of the first occurrence of the maximum value in a Series.

import pandas as pd

df_example = pd.DataFrame({
    'ProductID': ['A101-X', 'B202-YZ', 'C303-WXYZ'],
    'Description': ['Short', 'Medium', 'Longest String Here']
}, index=['id_0', 'id_1', 'id_2']) # Custom index for demo


# Get the Series of lengths
lengths = df_example['Description'].str.len()

# ✅ Get the index label of the first string with maximum length
index_of_longest = lengths.idxmax()
print(f"Index of the longest string in 'Description': {index_of_longest}")

# Get the value at that index
longest_value_at_index = df_example.loc[index_of_longest, 'Description']
print(f"Value at index '{index_of_longest}': '{longest_value_at_index}'")

Output:

Index of the longest string in 'Description': id_2
Value at index 'id_2': 'Longest String Here'

Finding Length of Longest String in Bytes (UTF-8)​

If your strings contain non-ASCII characters (e.g., accented letters, emojis), len() counts characters, not bytes. To get byte length (e.g., for UTF-8 encoding):

import pandas as pd

df_unicode = pd.DataFrame({'Name': ['Jürgen', 'Élise', '你好']})

# ✅ Length in bytes (UTF-8)
max_byte_length_utf8 = df_unicode['Name'].str.encode('utf-8').str.len().max()
print(f"Max byte length (UTF-8) in 'Name': {max_byte_length_utf8}")

Output:

Max byte length (UTF-8) in 'Name': 7
  • .str.encode('utf-8'): Encodes each string into bytes using UTF-8.
  • .str.len(): Called on the Series of bytes, returns the byte length.

Finding Maximum String Length for EACH Column in a DataFrame​

Using df.apply(lambda col: col.astype(str).str.len().max())​

Apply a function to each column that converts it to string, gets lengths, then max.

import pandas as pd

df_all_cols = pd.DataFrame({
    'ProductID': ['A1-X', 'B2-YZ', 'C3-WXYZ'],
    'Description': ['Short', 'Medium length', 'Very long description'],
    'NumericCol': [10, 12345, 99] # Will be converted to string for len()
})


# ✅ Get max string length for each column
# Convert to str first to handle numeric/other types safely before .str.len()
max_lengths_per_column = df_all_cols.apply(lambda x: x.astype(str).str.len().max())

print("Maximum string length for each column:")
print(max_lengths_per_column)
print()

# To apply only to object/string columns:
string_cols_df = df_all_cols.select_dtypes(include=['object', 'string'])
max_lengths_string_cols = string_cols_df.apply(lambda x: x.str.len().max())
print("Max string length for object/string columns only:")
print(max_lengths_string_cols)

Output:

Maximum string length for each column:
ProductID       7
Description    21
NumericCol      5
dtype: int64

Max string length for object/string columns only:
ProductID       7
Description    21
dtype: int64

Using numpy.vectorize (Alternative for all columns)​

This is more of a NumPy approach but can be applied.

import pandas as pd
import numpy as np

df_all_cols = pd.DataFrame({
    'ProductID': ['A1-X', 'B2-YZ', 'C3-WXYZ'],
    'Description': ['Short', 'Medium length', 'Very long description'],
    'NumericCol': [10, 12345, 99]
})

# Vectorized function to get length of string representation
len_str_vec = np.vectorize(lambda x: len(str(x)))

# Apply to the DataFrame's values, then take max along axis 0 (columns)
max_lengths_np = len_str_vec(df_all_cols.values).max(axis=0)
# This gives an array of max lengths. To map to column names:
max_lengths_dict_np = dict(zip(df_all_cols.columns, max_lengths_np))

print("Max string lengths per column (NumPy vectorize):")
print(pd.Series(max_lengths_dict_np))

Output:

Max string lengths per column (NumPy vectorize):
ProductID       7
Description    21
NumericCol      5
dtype: int32

The apply method with astype(str).str.len().max() is generally more idiomatic Pandas for this.

Conclusion​

To find the length of the longest string in a Pandas DataFrame column:

  • The most common and recommended method is your_series.str.len().max().
  • To get the actual longest string, use Python's max(your_series.dropna(), key=len).
  • To find the index of the first longest string, use your_series.str.len().idxmax().
  • For byte length (e.g., UTF-8), use your_series.str.encode('utf-8').str.len().max().
  • To find the max string length for all (or multiple) columns, use df.apply(lambda x: x.astype(str).str.len().max()).

These methods provide efficient and readable ways to analyze string lengths within your Pandas DataFrames.

Table of Contents