卧槽，好强大的魔法，竟能让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指定）。