卧槽,好强大的魔法,竟能让Python支持方法重载

 

 

1. 你真的了解方法重载吗?

方法重载是面向对象中一个非常重要的概念,在类中包含了成员方法和构造方法。如果类中存在多个同名,且参数(个数和类型)不同的成员方法或构造方法,那么这些成员方法或构造方法就被重载了。下面先给出一个Java的案例。

class MyOverload {
    public MyOverload() {
        System.out.println("MyOverload");
    }
    public MyOverload(int x) {
        System.out.println("MyOverload_int:" + x);
    }
    public MyOverload(long x) {
        System.out.println("MyOverload_long:" + x);
    }
    public MyOverload(String s, int x, float y, boolean flag) {
        System.out.println("MyOverload_String_int_float_boolean:" + s + x  + y + flag);
    }
}

这是一个Java类,有4个构造方法,很明显,这4个构造方法的参数个数和类型都不同。其中第2个构造方法和第3个构造方法尽管都有一个参数,但类型分别是int和long。而在Java中,整数默认被识别为int类型,如果要输入long类型的整数,需要后面加L,如20表示int类型的整数,而20L则表示long类型的整数。

如果要调用这4个构造方法,可以使用下面的代码:

new MyOverload();
new MyOverload(20);
new MyOverload(20L);
new MyOverload("hello",1,20.4f,false);


编译器会根据传入构造方法的参数值确定调用哪一个构造方法,例如,在分析new MyOverload(20)时,20被解析为int类型,所以会调用 public MyOverload(int x) {...}构造方法。

以上是Java语言中构造方法重载的定义和处理过程。Java之所以支持方法重载,是因为可以通过3个维度来确认到底使用哪一个重载形式,这3个维度是:
(1)方法名
(2)数据类型
(3)参数个数

如果这3个维度都相同,那么就会认为存在相同的构造方法,在编译时就会抛出异常。

方法的参数还有一种特殊形式,就是默认参数,也就是在定义参数时指定一个默认值,如果在调用该方法时不指定参数值,就会使用默认的参数值。

class MyClass {
    public test(int x, String s = "hello") {
        ... ...
    }
}


如果执行下面的代码,仍然是调用test方法。

new MyClass().test(20);

 

不过可惜的是,Java并不支持默认参数值,所以上面的形式并不能在Java中使用,如果要实现默认参数这种效果,唯一的选择就是方法重载。从另一个角度看,默认参数其实与方法重载是异曲同工的,也就是过程不同,但结果相同。所以Java并没有同时提供两种形式。


2. Python为什么在语法上不支持方法重载


首先下一个结论,Python不支持方法重载,至少在语法层次上不支持。但可以通过变通的方式来实现类似方法重载的效果。也就是说,按正常的方式不支持,但你想让他支持,那就支持。要知详情,继续看下面的内容。

我们先来看一下Python为什么不支持方法重载,前面说过,方法重载需要3个维度:方法名、数据类型和参数个数。但Python只有2个维度,那就是参数名和参数个数。所以下面的代码是没办法实现重载的。

class MyClass:
    def method(self, x,y):
        pass
    def method(self, a, b):
        pass  


在这段代码中,尽管两个method方法的形参名不同,但这些参数名在调用上无法区分,也就是说,如果使用下面的代码,Python编译器根本不清楚到底应该调用哪一个method方法。

MyClass().method(20, "hello")


由于Python是动态语言,所以变量的类型随时可能改变,因此,x、y、a、b可能是任何类型,所以就不能确定,20到底是x或a了。

不过Python有参数注解,也就是说,可以在参数后面标注数据类型,那么是不是可以利用这个注解实现方法重载呢?看下面的代码:

class MyClass:
    def method(self, x: int):
        print('int:', x)
    def method(self, x: str):
        print('str:',x)

MyClass().method(20)        
MyClass().method("hello")  


在这段代码中,两个method方法的x参数分别使用了int注解和str注解标注为整数类型和字符串类型。并且在调用时分别传入了20和hello。不过输出的却是如下内容:

str: 20
str: hello


这很显然都是调用了第2个method方法。那么这是怎么回事呢?

其实Python的类,就相当于一个字典,key是类的成员标识,value就是成员本身。不过可惜的是,在默认情况下,Python只会用成员名作为key,这样以来,两个method方法的key是相同的,都是method。Python会从头扫描所有的方法,遇到一个方法,就会将这个方法添加到类维护的字典中。这就会导致后一个方法会覆盖前一个同名的方法,所以MyClass类最后就剩下一个method方法了,也就是最后定义的method方法。所以就会输出前面的结果。也就是说,参数注解并不能实现方法的重载。

另外,要注意一点,参数注解也只是一个标注而已,与注释差不多。并不会影响传入参数的值。也就是说,将一个参数标注为int,也可以传入其他类型的值,如字符串类型。这个标注一般用作元数据,也就是给程序进行二次加工用的。

3. 用黑魔法让Python支持方法重载

既然Python默认不支持方法重载,那么有没有什么机制让Python支持方法重载呢?答案是:yes。

Python中有一种机制,叫魔法(magic)方法,也就是方法名前后各有两个下划线(_)的方法。如__setitem__、__call__等。通过这些方法,可以干预类的整个生命周期。

先说一下实现原理。在前面提到,类默认会以方法名作为key,将方法本身作为value,保存在类维护的字典中。其实这里可以做一个变通,只要利用魔法方法,将key改成方法名与类型的融合体,那么就可以区分具体的方法了。

这里的核心魔法方法是__setitem__,该方法在Python解析器没扫描到一个方法时调用,用于将方法保存在字典中。该方法有两个参数:key和value。key默认就是方法名,value是方法对象。我们只要改变这个key,将其变成方法名和类型的组合,就能达到我们的要求。

我们采用的方案是创建一个MultiMethod类,用于保存同名方法的所有实例,而key不变,仍然是方法名,只是value不再是方法对象,而是MultiMethod对象。然后MultiMethod内部维护一个字典,key是同名方法的类型组成的元组,value是对应的方法对象。

另外一个核心魔法方法是__call__,该方法在调用对象方法时被调用,可以在该方法中扫描调用时传入的值参的类型,然后将参数类型转换成元组,再到MultiMethod类维护的字典中搜索具体的方法实例,并在__call__方法中调用该方法实例,最后返回执行结果。

现在给出完整的实现代码:

import inspect
import types

class MultiMethod:

    def __init__(self, name):
        self._methods = {}
        self.__name__ = name

    def register(self, meth):
        '''
        根据方法参数类型注册一个新方法
        '''
        sig = inspect.signature(meth)

        # 用于保存方法参数的类型
        types = []
        for name, parm in sig.parameters.items():
            # 忽略self
            if name == 'self':
                continue
            if parm.annotation is inspect.Parameter.empty:
                raise TypeError(
                    '参数 {} 必须使用类型注释'.format(name)
                )
            if not isinstance(parm.annotation, type):
                raise TypeError(
                    '参数 {} 的注解必须是数据类型'.format(name)
                )
            if parm.default is not inspect.Parameter.empty:
                self._methods[tuple(types)] = meth
            types.append(parm.annotation)

        self._methods[tuple(types)] = meth
    # 当调用MyOverload类中的某个方法时,会执行__call__方法,在该方法中通过参数类型注解检测具体的方法实例,然后调用并返回执行结果
    def __call__(self, *args):
        '''
        使用新的标识表用方法
        '''
        types = tuple(type(arg) for arg in args[1:])
        meth = self._methods.get(types, None)
        if meth:
            return meth(*args)
        else:
            raise TypeError('No matching method for types {}'.format(types))

    def __get__(self, instance, cls):
        if instance is not None:
            return types.MethodType(self, instance)
        else:
            return self

class MultiDict(dict):
    def __setitem__(self, key, value):
        if key in self:
            # 如果key存在, 一定是MultiMethod类型或可调用的方法
            current_value = self[key]
            if isinstance(current_value, MultiMethod):
                current_value.register(value)
            else:
                mvalue = MultiMethod(key)
                mvalue.register(current_value)
                mvalue.register(value)
                super().__setitem__(key, mvalue)
        else:
            super().__setitem__(key, value)


class MultipleMeta(type):

    def __new__(cls, clsname, bases, clsdict):
        return type.__new__(cls, clsname, bases, dict(clsdict))

    @classmethod
    def __prepare__(cls, clsname, bases):
        return MultiDict()
# 任何类只要使用MultileMeta,就可以支持方法重载
class MyOverload(metaclass=MultipleMeta):
    def __init__(self):
        print("MyOverload")

    def __init__(self, x: int):
        print("MyOverload_int:", x)

    def bar(self, x: int, y:int):
        print('Bar 1:', x,y)

    def bar(self, s:str, n:int):
        print('Bar 2:', s, n)
    def foo(self, s:int, n:int):
        print('foo:', s, n)

    def foo(self, s: str, n: int):
        print('foo:', s, n)
    def foo(self, s: str, n: int, xx:float):
        print('foo:', s, n)
    def foo(self, s: str, n: int, xx:float,hy:float):
        print('foo:', s, n)

my = MyOverload(20)   # 调用的是第2个构造方法
my.bar(2, 3)
my.bar('hello',20)
my.foo(2, 3)
my.foo('hello',20)

运行程序,会输出如下的运行结果:

MyOverload_int: 20
Bar 1: 2 3
Bar 2: hello 20
foo: 2 3
foo: hello 20


很显然,构造方法、Bar方法和foo方法都成功重载了。以后如果要让一个类可以重载方法,可以直接使用MultipleMeta类(通过metaclass指定)。

 

 

posted on 2021-02-26 22:07  银河使者  阅读(791)  评论(16编辑  收藏  举报

导航