思路^_^：
1.创建表达式类(Exp、Const、Variable)，并实现eval(计算表达式的值)和deriv(求导)操作。
# 1.1 定义表达式
class Exp(object):
def eval(self, **kwargs): # 计算表达式的值
pass
def deriv(self, x): # 计算表达式的导数
pass
def __add__(self, other): # 运算符重载 e1 + e2
return Add(self, other).simplify()
def __sub__(self, other): # 运算符重载 e1 - e2
return Sub(self, other).simplify()
def __mul__(self, other): # 运算符重载 e1 * e2
return Mul(self, other).simplify()
def __truediv__(self, other): # 运算符重载 e1 / e2
return TrueDiv(self, other).simplify()
def __neg__(self): # 运算符重载 - e1
return Neg(self).simplify()
def __pow__(self, power): # 运算符重载 e1 ** e2
return Pow(self, power).simplify()
def __ln__(self): # 自定义的ln运算符
return Ln(self).simplify()
# 1.2 定义常量表达式
class Const(Exp):
def __init__(self, value):
self.value = value
def eval(self, **kwargs): # 计算表达式的值
return self.value
def deriv(self, x): # 计算表达式的导数
return Const(0)
def __repr__(self): # print时自动调用
return f"{self.value}"
# 1.3 定义变量表达式
class Variable(Exp):
def __init__(self, name):
self.name = name
def eval(self, **kwargs): # 计算表达式的值
if self.name in kwargs:
return kwargs[self.name]
raise NameError(f"name {self.name} is not found")
def deriv(self, x): # 计算表达式的导数
name = self.get_param_name(x)
return Const(1 if name == self.name else 0)
def __repr__(self): # print时自动调用
return self.name
def get_param_name(self, x):
if isinstance(x, Variable):
return x.name
if isinstance(x, str):
return x
raise TypeError(f"{x} is neither Variable nor str")
2.实现表达式的简单操作：加运算、取负运算、减运算、乘运算、除运算。
# 2.1 简单操作——加运算
class Add(Exp):
def __init__(self, left, right):
self.left = left
self.right = right
def eval(self, **kwargs):
return self.left.eval(**kwargs) + self.right.eval(**kwargs)
def deriv(self, x):
return self.left.deriv(x) + self.right.deriv(x)
def __repr__(self): # 为了可读性，判断是否要加括号()
if isinstance(self.left, (Const, Variable)):
if isinstance(self.right, Const):
if self.right.value < 0:
return f"{self.left} - {-self.right.value}"
else:
return f"{self.left} + {self.right}"
elif isinstance(self.right, Variable):
return f"{self.left} + {self.right}"
else:
return f"{self.left} + ({self.right})"
elif isinstance(self.right, (Const, Variable)):
if isinstance(self.right, Const) and self.right.value < 0:
return f"({self.left}) - {-self.right.value}"
else:
return f"({self.left}) + {self.right}"
else:
return f"({self.left}) + ({self.right})"
def simplify(self): # 简化表达式
if isinstance(self.left, Const):
if self.left.value == 0:
return self.right
if isinstance(self.right, Const):
return Const(self.left.value + self.right.value)
elif isinstance(self.right, Const) and self.right.value == 0:
return self.left
return self
# 2.2 简单操作——取负运算
class Neg(Exp):
def __init__(self, exp):
self.exp = exp
def eval(self, **kwargs):
return - self.exp.eval(**kwargs)
def deriv(self, x):
return - self.exp.deriv(x)
def __repr__(self): # 为了可读性，判断是否要加括号()
if isinstance(self.exp, Const):
return f"{-self.exp.value}"
if isinstance(self.exp, Variable):
return f"-{self.exp}"
return f"(-{self.exp})"
def simplify(self): # 简化表达式
if isinstance(self.exp, Const):
return Const(-self.exp.value)
return self
# 2.3 简单操作——减运算
class Sub(Exp):
def __init__(self, left, right):
self.left = left
self.right = right
def eval(self, **kwargs):
return self.left.eval(**kwargs) - self.right.eval(**kwargs)
def deriv(self, x):
return self.left.deriv(x) - self.right.deriv(x)
def __repr__(self): # 为了可读性，判断是否要加括号()
if isinstance(self.left, (Const, Variable)):
if isinstance(self.right, Const):
if self.right.value < 0:
return f"{self.left} + {-self.right.value}"
else:
return f"{self.left} - {self.right}"
elif isinstance(self.right, Variable):
return f"{self.left} - {self.right}"
else:
return f"{self.left} - ({self.right})"
elif isinstance(self.right, (Const, Variable)):
if isinstance(self.right, Const) and self.right.value < 0:
return f"({self.left}) + {-self.right.value}"
else:
return f"({self.left}) - {self.right}"
else:
return f"({self.left}) - ({self.right})"
def simplify(self): # 简化表达式
if isinstance(self.left, Const):
if self.left.value == 0:
return - self.right
if isinstance(self.right, Const):
return Const(self.left.value - self.right.value)
elif isinstance(self.right, Const) and self.right.value == 0:
return self.left
return self
# 2.4 简单操作——乘运算
class Mul(Exp):
def __init__(self, left, right):
self.left = left
self.right = right
def eval(self, **kwargs):
return self.left.eval(**kwargs) * self.right.eval(**kwargs)
def deriv(self, x):
u, v = self.left, self.right
# (uv)‘=u‘v + uv'
return u.deriv(x) * v + u * v.deriv(x)
def __repr__(self): # 为了可读性，判断是否要加括号()
if isinstance(self.left, (Const, Variable)):
if isinstance(self.right, Const):
if self.right.value < 0:
return f"{self.left} * ({self.right.value})"
else:
return f"{self.left} * {self.right}"
elif isinstance(self.right, Variable):
return f"{self.left} * {self.right}"
else:
return f"{self.left} * ({self.right})"
elif isinstance(self.right, (Const, Variable)):
if isinstance(self.right, Const) and self.right.value < 0:
return f"({self.left}) * ({self.right.value})"
else:
return f"({self.left}) * {self.right}"
else:
return f"({self.left}) * ({self.right})"
def simplify(self): # 简化表达式
if isinstance(self.left, Const):
if self.left.value == 0:
return Const(0)
if self.left.value == 1:
return self.right
if isinstance(self.right, Const):
return Const(self.left.value * self.right.value)
elif isinstance(self.right, Const):
if self.right.value == 0:
return Const(0)
if self.right.value == 1:
return self.left
return self
# 2.5 简单操作——除运算
class TrueDiv(Exp):
def __init__(self, left, right):
self.left = left
self.right = right
def eval(self, **kwargs):
return self.left.eval(**kwargs) / self.right.eval(**kwargs)
def deriv(self, x):
u, v = self.left, self.right
# (u/v)‘=(u‘v - uv')/(v*v)
return (u.deriv(x) * v - u * v.deriv(x)) / (v * v)
def __repr__(self): # 为了可读性，判断是否要加括号()
if isinstance(self.left, (Const, Variable)):
if isinstance(self.right, Const):
if self.right.value < 0:
return f"{self.left} / ({self.right.value})"
else:
return f"{self.left} / {self.right}"
elif isinstance(self.right, Variable):
return f"{self.left} / {self.right}"
else:
return f"{self.left} / ({self.right})"
elif isinstance(self.right, (Const, Variable)):
if isinstance(self.right, Const) and self.right.value < 0:
return f"({self.left}) / ({self.right.value})"
else:
return f"({self.left}) / {self.right}"
else:
return f"({self.left}) / ({self.right})"
def simplify(self): # 简化表达式
if isinstance(self.left, Const):
if self.left.value == 0:
return Const(0)
if isinstance(self.right, Const):
return Const(self.left.value / self.right.value)
elif isinstance(self.right, Const):
if self.right.value == 0:
raise ZeroDivisionError("division by zero")
if self.right.value == 1:
return self.left
return self
3.添加复杂操作：对数运算、幂运算。
# 3.1 复杂操作——对数运算
import math
# 自定义ln运算
def ln(exp):
return exp.__ln__()
class Ln(Exp):
def __init__(self, antilog):
self.antilog = antilog # 真数
def eval(self, **kwargs):
# math.log(x, [base=math.e])
x = self.antilog.eval(**kwargs)
if x <= 0:
raise ValueError("the antilog must be greater than zero")
return math.log(x)
def deriv(self, x):
# (lnf)‘=f‘/f
return self.antilog.deriv(x) / self.antilog
def __repr__(self): # 为了可读性，判断是否要加括号()
if isinstance(self.antilog, (Const, Variable)):
return f"ln{self.antilog}"
return f"ln({self.antilog})"
def simplify(self): # 简化表达式
if isinstance(self.antilog, Const) and self.antilog.value <= 0:
raise ValueError("the antilog must be greater than zero")
return self
# 3.2 复杂操作——幂运算
class Pow(Exp):
def __init__(self, base, power):
self.base = base
self.power = power
def eval(self, **kwargs):
return self.base.eval(**kwargs) ** self.power.eval(**kwargs)
def deriv(self, x):
f, g = self.base, self.power
# (f^g)‘=f^g*(g‘*ln(f) + g*f‘/f)
if g.deriv(x) == 0:
return f ** g * (g * f.deriv(x) / f)
return f ** g * (g.deriv(x) * ln(f) + g * f.deriv(x) / f)
def __repr__(self): # 为了可读性，判断是否要加括号()
if isinstance(self.base, Variable) or (isinstance(self.base, Const) and self.base.value >= 0):
if isinstance(self.power, Const):
if self.power.value < 0:
return f"{self.base} ** ({self.power.value})"
else:
return f"{self.base} ** {self.power}"
elif isinstance(self.power, Variable):
return f"{self.base} ** {self.power}"
else:
return f"{self.base} ** ({self.power})"
elif isinstance(self.power, (Const, Variable)):
if isinstance(self.power, Const) and self.power.value < 0:
return f"({self.base}) ** ({self.power.value})"
else:
return f"({self.base}) ** {self.power}"
else:
return f"({self.base}) ** ({self.power})"
def simplify(self): # 简化表达式
if isinstance(self.base, Const):
if self.base.value == 0:
return Const(0)
elif self.base.value == 1:
return Const(1)
# elif self.base.value < 0:
# raise ValueError("the base cannot be less than zero")
elif isinstance(self.power, Const):
return Const(self.base.value ** self.power.value)
elif isinstance(self.power, Const):
if self.power.value == 0:
return Const(1)
if self.power.value == 1:
return self.base
return self
