python 如何打印函数调用

要打印函数调用，可以使用print语句、logging模块、装饰器等方法。最常用的方法是通过print语句直接在函数内添加打印信息，或通过装饰器统一管理函数调用的打印。装饰器方法更为推荐，因为它可以将打印逻辑与业务逻辑分离，提高代码的可维护性和可读性。

下面详细介绍如何通过装饰器来打印函数调用。

一、使用print语句

print语句 是最简单直接的方法，可以在每个函数的开头和结尾添加print语句，以打印函数调用的信息。

def my_function(x, y):
    print(f"Calling my_function with arguments: x={x}, y={y}")
    result = x + y
    print(f"Result of my_function: {result}")
    return result
my_function(3, 4)

二、使用logging模块

logging模块 提供了比print语句更强大的功能，可以记录不同级别的日志信息，并且可以灵活地配置输出格式和目标。

import logging
logging.basicConfig(level=logging.INFO)
def my_function(x, y):
    logging.info(f"Calling my_function with arguments: x={x}, y={y}")
    result = x + y
    logging.info(f"Result of my_function: {result}")
    return result
my_function(3, 4)

三、使用装饰器

装饰器是一个更为优雅的解决方案，可以将函数调用的打印逻辑与业务逻辑分离，增强代码的可维护性。

def log_function_call(func):
    def wrapper(*args, kwargs):
        print(f"Calling {func.__name__} with arguments: {args}, {kwargs}")
        result = func(*args, kwargs)
        print(f"Result of {func.__name__}: {result}")
        return result
    return wrapper
@log_function_call
def my_function(x, y):
    return x + y
my_function(3, 4)

四、深入介绍装饰器

1、什么是装饰器

装饰器是一种特殊的函数，它接受一个函数作为参数，并返回一个新的函数。装饰器通常用于在不修改原函数代码的情况下，添加额外的功能。

2、如何定义和使用装饰器

定义一个装饰器非常简单，只需要定义一个接受函数作为参数的函数，然后在这个函数内定义一个新的函数（通常称为wrapper），这个新的函数会在原函数调用前后添加额外的功能。

def my_decorator(func):
    def wrapper(*args, kwargs):
        # 在这里添加前置功能
        print(f"Calling {func.__name__} with arguments: {args}, {kwargs}")
        result = func(*args, kwargs)
        # 在这里添加后置功能
        print(f"Result of {func.__name__}: {result}")
        return result
    return wrapper

3、示例：打印函数调用

我们可以使用上述定义的装饰器来打印函数调用的详细信息。

@my_decorator
def add(a, b):
    return a + b
add(2, 3)

运行上述代码会输出：

Calling add with arguments: (2, 3), {}
Result of add: 5

4、更多复杂的装饰器

装饰器不仅可以用于打印函数调用，还可以用于其他用途，例如：执行时间测量、权限检查、缓存等。下面是一个稍微复杂的装饰器示例，它不仅打印函数调用，还记录函数执行的时间。

import time
def timing_decorator(func):
    def wrapper(*args, kwargs):
        start_time = time.time()
        print(f"Calling {func.__name__} with arguments: {args}, {kwargs}")
        result = func(*args, kwargs)
        end_time = time.time()
        print(f"Result of {func.__name__}: {result}")
        print(f"Execution time of {func.__name__}: {end_time - start_time} seconds")
        return result
    return wrapper
@timing_decorator
def slow_function(seconds):
    time.sleep(seconds)
    return f"Slept for {seconds} seconds"
slow_function(2)

5、类装饰器

除了函数装饰器，还有一种装饰器是应用于类的，称为类装饰器。类装饰器可以用于在类实例化前后添加额外的行为。

def class_decorator(cls):
    class Wrapper:
        def __init__(self, *args, kwargs):
            print(f"Creating instance of {cls.__name__} with arguments: {args}, {kwargs}")
            self.instance = cls(*args, kwargs)
        def __getattr__(self, name):
            return getattr(self.instance, name)
    return Wrapper
@class_decorator
class MyClass:
    def __init__(self, x):
        self.x = x
    def display(self):
        print(f"MyClass instance with x={self.x}")
obj = MyClass(10)
obj.display()

运行上述代码会输出：

Creating instance of MyClass with arguments: (10,), {}
MyClass instance with x=10

6、装饰器的嵌套和组合

装饰器可以嵌套和组合使用，这使得它们非常灵活。例如，可以先应用一个用于打印函数调用的装饰器，再应用一个用于测量执行时间的装饰器。

@timing_decorator
@my_decorator
def combined_function(x, y):
    return x * y
combined_function(4, 5)

运行上述代码会输出：

Calling combined_function with arguments: (4, 5), {}
Calling wrapper with arguments: (4, 5), {}
Result of wrapper: 20
Execution time of wrapper: <time> seconds
Result of combined_function: 20
Execution time of combined_function: <time> seconds

7、传递参数给装饰器

有时我们需要为装饰器传递参数，这可以通过再嵌套一层函数来实现。

def log_with_level(level):
    def decorator(func):
        def wrapper(*args, kwargs):
            if level == "info":
                print(f"INFO: Calling {func.__name__} with arguments: {args}, {kwargs}")
            result = func(*args, kwargs)
            if level == "info":
                print(f"INFO: Result of {func.__name__}: {result}")
            return result
        return wrapper
    return decorator
@log_with_level("info")
def multiply(a, b):
    return a * b
multiply(3, 4)

8、使用functools.wraps保留原函数信息

在装饰器中使用functools.wraps可以保留原函数的名称、文档字符串等信息，这在调试和文档生成时非常有用。

import functools
def my_decorator(func):
    @functools.wraps(func)
    def wrapper(*args, kwargs):
        print(f"Calling {func.__name__} with arguments: {args}, {kwargs}")
        result = func(*args, kwargs)
        print(f"Result of {func.__name__}: {result}")
        return result
    return wrapper
@my_decorator
def add(a, b):
    """Add two numbers."""
    return a + b
print(add.__name__)  # 输出: add
print(add.__doc__)   # 输出: Add two numbers.