SymPy符号在函数默认参数中的陷阱与解决方案：理解对象同一性

import sympy as sy

# 创建三个符号
y1 = sy.symbols('y')
y2 = sy.symbols('y')
y3 = sy.symbols('y', real=True) # 带有不同假设的符号

print(f"y1: {y1}, Python对象ID: {id(y1)}")
print(f"y2: {y2}, Python对象ID: {id(y2)}")
print(f"y3: {y3}, Python对象ID: {id(y3)}")

# 比较符号的数学相等性 (==) 和对象同一性 (is)
print(f"\ny1 == y2 (数学相等性): {y1 == y2}") # True，因为它们代表相同的数学符号（名称和默认假设相同）
print(f"y1 is y2 (对象同一性): {y1 is y2}")   # False，它们是不同的Python对象

print(f"\ny1 == y3 (数学相等性): {y1 == y3}") # False，因为y3有不同的假设 (real=True)
print(f"y1 is y3 (对象同一性): {y1 is y3}")   # False

import sympy as sy

def addtwo_problematic(y = sy.symbols('y', reals = True)):
    """
    此函数使用sympy符号作为默认参数。
    默认参数y在函数定义时被评估一次，创建一个符号对象。
    """
    return y + 2

# 在函数外部创建一个名为'y'的符号
y_external = sy.symbols('y')

# 调用函数时不传入参数，使用默认的y
expr_default = addtwo_problematic()
print(f"生成的表达式: {expr_default}")
print(f"表达式类型: {type(expr_default)}")

# 尝试使用外部符号y_external进行替换
print(f"尝试替换 (y_external, 1): {expr_default.subs(y_external, 1)}")

生成的表达式: y + 2
表达式类型: <class 'sympy.core.add.Add'>
尝试替换 (y_external, 1): y + 2

import sympy as sy

def addtwo_solution(y = sy.symbols('y', reals = True)):
    """
    此函数与addtwo_problematic相同，但我们将演示如何正确替换。
    """
    return y + 2

# 调用函数时不传入参数，使用默认的y
expr_solution = addtwo_solution()

# 从表达式中提取实际的符号对象
# .free_symbols 返回一个包含表达式中所有自由符号的集合
# 对于只含一个符号的表达式，.pop() 可以安全地取出该符号
actual_y_in_expr = expr_solution.free_symbols.pop()

print(f"生成的表达式: {expr_solution}")
print(f"表达式中的实际符号: {actual_y_in_expr}, Python对象ID: {id(actual_y_in_expr)}")

# 现在使用从表达式中提取出的实际符号进行替换
print(f"尝试替换 (actual_y_in_expr, 1): {expr_solution.subs(actual_y_in_expr, 1)}")

生成的表达式: y + 2
表达式中的实际符号: y, Python对象ID: 140024987178320 # 示例ID，每次运行可能不同
尝试替换 (actual_y_in_expr, 1): 3

import sympy as sy

def addtwo_explicit(y_param):
    """
    此函数显式接受一个SymPy符号作为参数。
    """
    return y_param + 2

# 在函数外部创建符号
y_explicit = sy.symbols('y', reals=True)

# 调用函数时传入外部创建的符号
expr_explicit = addtwo_explicit(y_explicit)

print(f"生成的表达式: {expr_explicit}")

# 使用传入函数的同一个符号进行替换
print(f"尝试替换 (y_explicit, 1): {expr_explicit.subs(y_explicit, 1)}")

生成的表达式: y + 2
尝试替换 (y_explicit, 1): 3