Fix: Typeerror ‘series’ object is not callable

When working with Pandas Series in Python, you may encounter the following error:

TypeError: 'Series' object is not callable

This occurs when you try to call a Pandas Series directly as if it were a function, rather than a data object.

In this comprehensive guide, we’ll cover:

  • The causes of this confusing TypeError
  • Clear examples of when it manifests
  • 3 different solutions to fix it
  • Tips for avoiding similar issues

Knowing how to untangle these “not callable” pandas errors will help you write robust Python data analysis code. Let’s dive in!

Understanding the “Series Not Callable” TypeError

The root cause of this error is attempting to directly call a Pandas Series as if it were a callable function:

import pandas as pd

data = pd.Series([1, 2, 3]) 

# TypeError!

But Series are data objects, not callable functions. So Python raises a TypeError informing us that this Series object does not support being called like a function.

The key is understanding what types of invalid Series operations can trigger this.

When Does This Error Occur?

There are two main invalid ways of using a Series that result in the “not callable” error:

1. Attempting to Call Series Directly

This is the most common cause – trying to execute a Series like a function:

data = pd.Series([1, 2, 3])

# Treating Series as callable function

But this is invalid, resulting in our TypeError.

2. Using Series as Callable Function Argument

Passing a Series where a callable function is expected also errors:

def call_func(func):
  return func(0)

data = pd.Series([1, 2, 3])  

# Passing Series as invalid callable  

Since data is a Series, not a function, we get a TypeError again.

Understanding these two main cases where Series are misused as callables clarifies when this issue occurs.

Now let’s explore how to properly fix it.

Solution 1: Access Elements Instead of Calling

The key to resolving the “Series not callable” error is to avoid directly calling the Series.

Instead, access Series elements using square bracket notation:

data = pd.Series([1, 2, 3])

# CALLING data results in TypeError 

# CORRECT USAGE - access via square brackets
print(data[0]) # 1

Square brackets let you retrieve values from the Series without attempting to call it like a function.

This is the simplest fix in most cases to avoid the TypeError.

Solution 2: Pass Series Iterator Instead of Object

When passing a Series to a function requiring a callable, wrap it in a generator expression rather than passing the raw object:

def call_func(func):
  return func(0)
data = pd.Series([1, 2, 3])  

# INCORRECT - passing raw Series 
call_func(data) # TypeError!

# CORRECT - pass generator expression instead  
call_func((x for x in data)) # Ok!

This creates an iterator from the Series that provides callable functionality.

So for cases where a callable is needed, passing a Series iterator avoids the “not callable” error.

Solution 3: Wrap Series in Custom Callable Class

For advanced situations, you can wrap a Series in a thin callable class:

class SeriesCallable:
  def __init__(self, series):
    self.series = series
  def __call__(self, index):
    return self.series[index]

data = pd.Series([1, 2, 3])  

# Wrap Series in custom callable class
callable_series = SeriesCallable(data)

# Now we can call it without TypeError!

This gives you full control over the callable behavior while encapsulating the Series.

The key ideas are understanding callables vs plain data objects, and not misusing Series as direct callables.

Best Practices for Avoiding This Error

To prevent similar errors, keep these best practices in mind:

  • Use square bracket notation to access Series values
  • Avoid calling Series like functions or passing them to functions expecting callables
  • Wrap Series in generator expressions or custom classes when you need callable behavior
  • Double check for errors when passing Series to external libraries

Carefully differentiating between callable and non-callable types in Pandas will help you avoid other confusing TypeErrors.


The “TypeError: ‘Series’ object is not callable” error occurs when attempting to directly call Pandas Series objects as functions.

Accessing values via indices instead of calling, using generator expressions, and creating thin callable wrappers provides workarounds to avoid the issue.

Understanding when Pandas objects are callable vs not callable helps write robust data analysis programs that are resilient to TypeErrors.

Now you have a guide to overcoming this common Pandas “not callable” pitfall – and can continue productively working with Series without frustration!

Leave a Comment