python二元函数,二元运算举例

　　相关学习推荐：python教程

　　每个人都对我解释属性访问的博客文章反应热烈，这启发我写了另一篇关于Python中有多少语法实际上只是语法糖的文章。在这篇文章中，我想谈谈二进制算术运算。

　　具体来说，我想解读一下减法的工作原理：A-B，我特意选择了减法，因为它不可交换。这可以强调操作顺序的重要性。与加法运算相比，你可能在实现中错误地翻转A和B，但仍然得到相同的结果。

　　00-1010按照惯例，我们从看CPython解释器编译的字节码开始。

　　DEF () :A-B.import dis . dis(sub)1 0 load _ global 0(a)2 load _ global 1(b)4 Binary _ Subtract 6 pop _ top 8 load _ const 0(none)10 return _ Value复制代码看来我们需要深入研究BINARY _ SUBTRACT操作码了。查找Python/ceval.c文件，可以看到实现这个操作码的C代码如下：

　　案例目标(BINARY_SUBTRACT): {

　　py object * right=POP()；

　　py object * left=TOP()；

　　py object * diff=py number _ Subtract(left，right)；

　　Py_DECREF(右)；

　　Py_DECREF(左)；

　　SET _ TOP(diff)；if (diff==NULL) goto错误；

　　分派()；

　　}复制代码来源：github.com/python/cpyt…

　　这里的关键代码是PyNumber_Subtract()，它实现了减法的实际语义。继续看这个函数的一些宏，可以找到binary_op1()函数。它提供了管理二元运算的通用方法。

　　但是，我们不把它作为实现的参考，而是使用Python的数据模型。官方文档很好，明确介绍了减法中使用的语义。

　　00-1010通读数据模型的文档，你会发现有两个方法在实现减法时起着关键作用：__sub__和__rsub__。

　　00-1010执行a-b时，它会在A的类型中寻找__sub__()然后把B作为它的参数。这与我写的关于属性访问的文章中的__getattribute__()非常相似。special/magic方法根据对象的类型解析对象，而不是出于性能目的解析对象本身；在下面的示例代码中，我使用_mro_getattr()来表示这个过程。

　　因此，如果定义了__sub__()，则键入(a)。__sub__(a，b)将用于减法。魔法属于客体的类型，不是客体。

　　这意味着本质上减法只是一个方法调用！也可以理解为标准库中的operator.sub()函数。

　　我们会模仿这个函数来实现自己的模型，用lhs和rhs这两个名字分别代表a-b的左右两边，让示例代码更容易理解。

　　#通过调用_ __sub__()，实现减法def sub (lhs:any，rhs3360any，/)-any3360

　　“实现二元运算‘a-b’。”

　　lhs_type=type(lhs) try:

　　subtract=_mro_getattr(lhs_type， _ _ sub _ _ )attribute error :除外

　　msg=f 不支持-: {lhs_type！r}和{type(rhs)！r}

　　raiseypeerror(MSG)else 3360 Return Subtract(LHS，RHS)复制代码

查看 C 代码

然而，如果A没有实现__s

　　ub__() 怎么办？如果 a 和 b 是不同的类型，那么我们会尝试调用 b 的 __rsub__()（__rsub__ 里面的“r”表示“右”，代表在操作符的右侧）。

　　当操作的双方是不同类型时，这样可以确保它们都有机会尝试使表达式生效。当它们相同时，我们假设__sub__() 就能够处理好。但是，即使两边的实现相同，你仍然要调用__rsub__()，以防其中一个对象是其它的（子）类。

3、不关心类型

现在，表达式双方都可以参与运算！但是，如果由于某种原因，某个对象的类型不支持减法怎么办（例如不支持 4 - “stuff”）？在这种情况下，__sub__ 或__rsub__ 能做的就是返回 NotImplemented。

　　这是给 Python 返回的信号，它应该继续执行下一个操作，尝试使代码正常运行。对于我们的代码，这意味着需要先检查方法的返回值，然后才能假定它起作用。

# 减法的实现，其中表达式的左侧和右侧均可参与运算_MISSING = object()def sub(lhs: Any, rhs: Any, /) -> Any:
　　 # lhs.__sub__
　　 lhs_type = type(lhs) try:
　　 lhs_method = debuiltins._mro_getattr(lhs_type, "__sub__") except AttributeError:
　　 lhs_method = _MISSING # lhs.__rsub__ (for knowing if rhs.__rub__ should be called first)
　　 try:
　　 lhs_rmethod = debuiltins._mro_getattr(lhs_type, "__rsub__") except AttributeError:
　　 lhs_rmethod = _MISSING # rhs.__rsub__
　　 rhs_type = type(rhs) try:
　　 rhs_method = debuiltins._mro_getattr(rhs_type, "__rsub__") except AttributeError:
　　 rhs_method = _MISSING
　　 call_lhs = lhs, lhs_method, rhs
　　 call_rhs = rhs, rhs_method, lhs if lhs_type is not rhs_type:
　　 calls = call_lhs, call_rhs else:
　　 calls = (call_lhs,) for first_obj, meth, second_obj in calls: if meth is _MISSING: continue
　　 value = meth(first_obj, second_obj) if value is not NotImplemented: return value else: raise TypeError( f"unsupported operand type(s) for -: {lhs_type!r} and {rhs_type!r}"
　　 )复制代码

4、子类优先于父类

如果你看一下__rsub__() 的文档，就会注意到一条注释。它说如果一个减法表达式的右侧是左侧的子类（真正的子类，同一类的不算），并且两个对象的__rsub__() 方法不同，则在调用__sub__() 之前会先调用__rsub__()。换句话说，如果 b 是 a 的子类，调用的顺序就会被颠倒。

　　这似乎是一个很奇怪的特例，但它背后是有原因的。当你创建一个子类时，这意味着你要在父类提供的操作上注入新的逻辑。这种逻辑不一定要加给父类，否则父类在对子类操作时，就很容易覆盖子类想要实现的操作。

　　具体来说，假设有一个名为 Spam 的类，当你执行 Spam() - Spam() 时，得到一个 LessSpam 的实例。接着你又创建了一个 Spam 的子类名为 Bacon，这样，当你用 Spam 去减 Bacon 时，你得到的是 VeggieSpam。

　　如果没有上述规则，Spam() - Bacon() 将得到 LessSpam，因为 Spam 不知道减掉 Bacon 应该得出 VeggieSpam。

　　但是，有了上述规则，就会得到预期的结果 VeggieSpam，因为 Bacon.__rsub__() 首先会在表达式中被调用（如果计算的是 Bacon() - Spam()，那么也会得到正确的结果，因为首先会调用 Bacon.__sub__()，因此，规则里才会说两个类的不同的方法需有区别，而不仅仅是一个由 issubclass() 判断出的子类。）

# Python中减法的完整实现_MISSING = object()def sub(lhs: Any, rhs: Any, /) -> Any:
　　 # lhs.__sub__
　　 lhs_type = type(lhs) try:
　　 lhs_method = debuiltins._mro_getattr(lhs_type, "__sub__") except AttributeError:
　　 lhs_method = _MISSING # lhs.__rsub__ (for knowing if rhs.__rub__ should be called first)
　　 try:
　　 lhs_rmethod = debuiltins._mro_getattr(lhs_type, "__rsub__") except AttributeError:
　　 lhs_rmethod = _MISSING # rhs.__rsub__
　　 rhs_type = type(rhs) try:
　　 rhs_method = debuiltins._mro_getattr(rhs_type, "__rsub__") except AttributeError:
　　 rhs_method = _MISSING
　　 call_lhs = lhs, lhs_method, rhs
　　 call_rhs = rhs, rhs_method, lhs if (
　　 rhs_type is not _MISSING # Do we care?
　　 and rhs_type is not lhs_type # Could RHS be a subclass?
　　 and issubclass(rhs_type, lhs_type) # RHS is a subclass!
　　 and lhs_rmethod is not rhs_method # Is __r*__ actually different?
　　 ):
　　 calls = call_rhs, call_lhs elif lhs_type is not rhs_type:
　　 calls = call_lhs, call_rhs else:
　　 calls = (call_lhs,) for first_obj, meth, second_obj in calls: if meth is _MISSING: continue
　　 value = meth(first_obj, second_obj) if value is not NotImplemented: return value else: raise TypeError( f"unsupported operand type(s) for -: {lhs_type!r} and {rhs_type!r}"
　　 )复制代码

推广到其它二元运算

解决掉了减法运算，那么其它二元运算又如何呢？好吧，事实证明它们的操作相同，只是碰巧使用了不同的特殊/魔术方法名称。

　　所以，如果我们可以推广这种方法，那么我们就可以实现 13 种操作的语义：+ 、-、*、@、/、//、％、**、<<、>>、＆、^、和。

　　由于闭包和 Python 在对象自省上的灵活性，我们可以提炼出 operator 函数的创建。

# 一个创建闭包的函数，实现了二元运算的逻辑_MISSING = object()def _create_binary_op(name: str, operator: str) -> Any:
　　 """Create a binary operation function.
　　 The `name` parameter specifies the name of the special method used for the
　　 binary operation (e.g. `sub` for `__sub__`). The `operator` name is the
　　 token representing the binary operation (e.g. `-` for subtraction).
　　 """
　　 lhs_method_name = f"__{name}__"
　　 def binary_op(lhs: Any, rhs: Any, /) -> Any:
　　 """A closure implementing a binary operation in Python."""
　　 rhs_method_name = f"__r{name}__"
　　 # lhs.__*__
　　 lhs_type = type(lhs) try:
　　 lhs_method = debuiltins._mro_getattr(lhs_type, lhs_method_name) except AttributeError:
　　 lhs_method = _MISSING # lhs.__r*__ (for knowing if rhs.__r*__ should be called first)
　　 try:
　　 lhs_rmethod = debuiltins._mro_getattr(lhs_type, rhs_method_name) except AttributeError:
　　 lhs_rmethod = _MISSING # rhs.__r*__
　　 rhs_type = type(rhs) try:
　　 rhs_method = debuiltins._mro_getattr(rhs_type, rhs_method_name) except AttributeError:
　　 rhs_method = _MISSING
　　 call_lhs = lhs, lhs_method, rhs
　　 call_rhs = rhs, rhs_method, lhs if (
　　 rhs_type is not _MISSING # Do we care?
　　 and rhs_type is not lhs_type # Could RHS be a subclass?
　　 and issubclass(rhs_type, lhs_type) # RHS is a subclass!
　　 and lhs_rmethod is not rhs_method # Is __r*__ actually different?
　　 ):
　　 calls = call_rhs, call_lhs elif lhs_type is not rhs_type:
　　 calls = call_lhs, call_rhs else:
　　 calls = (call_lhs,) for first_obj, meth, second_obj in calls: if meth is _MISSING: continue
　　 value = meth(first_obj, second_obj) if value is not NotImplemented: return value else:
　　 exc = TypeError( f"unsupported operand type(s) for {operator}: {lhs_type!r} and {rhs_type!r}"
　　 )
　　 exc._binary_op = operator raise exc复制代码

有了这段代码，你可以将减法运算定义为 _create_binary_op(“sub”, “-”)，然后根据需要重复定义出其它运算。

想了解更多编程学习，敬请关注php培训栏目！
　　

以上就是Python 的二元算术运算详解的详细内容，更多请关注盛行IT软件开发工作室其它相关文章！

郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。

查看 C 代码

3、不关心类型

4、子类优先于父类

推广到其它二元运算

相关文章阅读