Understanding Function Calls and References in Python

In Python programming, functions are the cornerstone of code reuse and modularity. Understanding function calls and references helps organize code, improve flexibility, and maintainability.

Basic concepts : A function call executes a function by its name, passing arguments and returning a result. A function reference treats the function as an object that can be assigned to variables, passed as arguments, or returned from other functions.

Common calling methods : Direct call (e.g., greet("Alice")), indirect call via a variable (func = greet; func("Bob")), and passing functions as arguments to higher‑order functions such as map() or filter().

Advanced applications : Using functions as parameters, return values (creating closures), assigning functions to object attributes, dynamic invocation via locals(), storing functions in dictionaries or lists, using functions as decorators, and employing callbacks.

Code examples :

Direct call:

def greet(name):
    print(f"你好，{name}！")
greet("Alice")  # 直接调用

Indirect call:

def greet(name):
    print(f"你好，{name}！")
func = greet
func("Bob")  # 间接调用

Function as argument:

def add(a, b):
    return a + b
def subtract(a, b):
    return a - b
def apply_operation(func, a, b):
    return func(a, b)
result = apply_operation(add, 5, 3)
print(f"加法结果：{result}")
result = apply_operation(subtract, 5, 3)
print(f"减法结果：{result}")

Function as return value (closure):

def get_operation(operation):
    if operation == "add":
        return lambda a, b: a + b
    elif operation == "subtract":
        return lambda a, b: a - b
add_func = get_operation("add")
subtract_func = get_operation("subtract")
print(f"加法结果：{add_func(5, 3)}")
print(f"减法结果：{subtract_func(5, 3)}")

Function as object attribute:

class Calculator:
    def add(self, a, b):
        return a + b
    def subtract(self, a, b):
        return a - b
calc = Calculator()
func = calc.add
print(f"加法结果：{func(5, 3)}")

Dynamic call via locals():

def greet(name):
    print(f"你好，{name}！")
def farewell(name):
    print(f"再见，{name}！")
func_name = "greet"
func = locals()[func_name]
func("Alice")

Function stored in a dictionary:

def add(a, b):
    return a + b
def subtract(a, b):
    return a - b
operations = {"add": add, "subtract": subtract}
result = operations["add"](5, 3)
print(f"加法结果：{result}")
result = operations["subtract"](5, 3)
print(f"减法结果：{result}")

Function stored in a list:

def greet(name):
    print(f"你好，{name}！")
def farewell(name):
    print(f"再见，{name}！")
functions = [greet, farewell]
functions[0]("Alice")
functions[1]("Alice")

Function as decorator:

def my_decorator(func):
    def wrapper():
        print("在函数执行前添加一些逻辑")
        func()
        print("在函数执行后添加一些逻辑")
    return wrapper

@my_decorator
def say_hello():
    print("Hello！")
say_hello()

Closure example:

def outer(x):
    def inner(y):
        return x + y
    return inner
add_10 = outer(10)
print(f"10 + 5 的结果：{add_10(5)}")

Callback example:

def handle_event(callback):
    print("事件触发")
    callback()
handle_event(lambda: print("这是一个回调函数"))

Mapping with map():

def square(x):
    return x ** 2
numbers = [1, 2, 3, 4, 5]
squared_numbers = list(map(square, numbers))
print(f"平方后的结果：{squared_numbers}")

Summary : Function calls and references are essential in Python. By mastering direct and indirect calls, passing functions as arguments, returning functions, and leveraging functions as objects, developers can write more flexible and powerful code, including dynamic invocation, closures, decorators, and callbacks.