How to get the caller's method name in the called method?

Substitutes and Stumbling Blocks

If inspect doesn't get you there, you might be tempted by sys._getframe(). But not so fast, my eager friend:

import sys

def called_method():
    # The secret identity of the caller
    print(f"Caller: {sys._getframe(1).f_code.co_name}")

def caller():
    # The secret phone-booth of said caller
    called_method()

caller()


The output remains the same but, beware: sys._getframe() is internal and unofficial. Using it in production code is like asking for a Joker in your Python's Gotham City.

The Hustle for Efficiency

Now remember, inspect.stack() might eat pie right from your performance resources:

def called_method():
    # Are we there yet?
    caller_name = inspect.stack()[1][3]
    # ... the story continues ...


Less resource-hogging, and faster than a caffeinated python, this variant gets you there quicker:

def called_method():
    # The caller's name in an instant
    caller_name = inspect.currentframe().f_back.f_code.co_name
    # ... just in time for tea ...


If you're on a debugging safari, inspect.stack() is your telescope, but for production, jump on the speed train with currentframe().

Memory Quirks: the Frame Leaks

Here's a quirk: holding onto the entire frame object longer than necessary can cause frame leaks. Handle with care, disarming the ora after extracting the information.

Your Call Stack Guide

Let's dive into how the call stack can serve you:

import inspect

def called_method():
    # Skip 0 to keep the current party out
    caller_info = inspect.stack()[1]
    # Skillfully extract what you need and leave the rest
    caller_name, filename, line_number, function_name, code_context, index = caller_info
    print(f"Summoned by '{function_name}' at line {line_number} in file '{filename}'.")


This copious procedure can scout the caller's context more effectively than simple method name retrieval.

Contingencies: Different Contexts

Classes and Modules

When dealing with class methods or different modules, the game takes a twist:

class MyClass:
    def method_one(self):
        # Invokes method_two
        self.method_two()
    
    def method_two(self):
        print(f"Summoned by: {inspect.stack()[1][3]}")

my_instance = MyClass()
my_instance.method_one()


This confirms that method_one is calling method_two.

The Case of the Nameless

Our detective turns to the nameless suspects - lambdas and the like:

(lambda: called_method())()


There are no escapees under the watch of inspect.stack()[1][3], which returns '<lambda>'.

Main Scope Calls

Sometimes, a called method might need to check if it's been called from the main scope:

if __name__ == '__main__':
    def called_method():
        print("Summoned by the main scope.")

    called_method()


This snippet conclusively reveals if the method was directly invoked from the main module.