Python でメソッドの後付け的なことをするにはどうすればよいのか？

Question

普段 Julia を書いているのですが、Python でどう管理すればよいのか分からないことがあります。
クラスによって異なる実装になるかもしれないのですが、同じ意味の値を返す関数をいろんな既存のモジュールのクラスについて定義したいのですが、やり方がよく分かりません。自作のモジュールなら、そのモジュールをいじって、該当クラスのメソッドを追加すれば良いだけですが、既存のモジュールにその関数を別名を付けないで実装するにはどうすれば良いのでしょうか？Python では、同じ名前を付けたい場合は、関数の引数の型に関するオーバーロードはないので、多くの場合、クラスのメソッドとしてその機能を提供すると思うのですが、既存のクラスをいじりたい場合はどうすれば良いのでしょうか？

現在はとりあえず、型ごとに別名を関数のお尻に付けて対処していますが、段々増えてきて煩雑になってきてしまったのでどうにかしたいです。

例えば、現在、

```python
import modulea
import moduleb

def func1_a(a1: modulea.TypeA, a2: modulea.TypeA) -> modulea.TypeA:
    a = a1 + a2
    return a
def func1_b(b1: moduleb.TypeB, b2: moduleb.TypeB) -> moduleb.TypeB:
    b = b1 + b2
    return b
def func2_a(a1: modulea.TypeA, a2: modulea.TypeA) -> modulea.TypeA:
    a = a1 - a2
    return a
def func2_b(b: moduleb.TypeB, b2: moduleb.TypeB) -> moduleb.TypeB:
    b = b1 - b2
    return b

# 関数を使うとき

func1_a(a1, a2)
func1_b(b1, b2)
func2_a(a1, a2)
func2_b(b1, b2)
```

こんな感じになっているのを

```python
func1(a1, a2)
func1(b1, b2)
func2(a1, a2)
func2(b1, b2)
```

または

```python
a1.func1(a2)
b1.func1(b2)
a1.func2(a2)
b1.func2(b2)
```

として管理したいということです。

Accepted Answer

事前にこういうことをやっておけば、
```python
modulea.TypeA.func1 = func1_a
moduleb.TypeB.func1 = func1_b
modulea.TypeA.func2 = func2_a
moduleb.TypeB.func2 = func2_b
```

このように書くことは可能。
```python
a1.func1(a2)
b1.func1(b2)
a1.func2(a2)
b1.func2(b2)
```

ただし、該当のクラスが特殊な型(組み込み型やC拡張モジュールで定義された型など)だとできない。
(こちらの記事の方法であれば可能: [[Python] build-in objectに独自のメソッドを追加する禁断の果実](https://e-tec-memo.herokuapp.com/article/283/))
あと、事前に別名で関数として定義しなければならないので、名前付けの問題は残る。
(直接ラムダ式を代入することもできるけど、ラムダ式だとできることが限られる)


他に、[functools.singledispatch](https://docs.python.org/ja/3/library/functools.html#functools.singledispatch)を使う方法もある。
```python
from functools import singledispatch

@singledispatch
def func1(arg1, arg2):
    pass
@func1.register
def _(a1: modulea.TypeA, a2: modulea.TypeA) -> modulea.TypeA:
    a = a1 + a2
    return a
@func1.register
def _(b1: moduleb.TypeB, b2: moduleb.TypeB) -> moduleb.TypeB:
    b = b1 + b2
    return b

@singledispatch
def func2(arg1, arg2):
    pass
@func2.register
def _(a1: modulea.TypeA, a2: modulea.TypeA) -> modulea.TypeA:
    a = a1 - a2
    return a
@func2.register
def _(b: moduleb.TypeB, b2: moduleb.TypeB) -> moduleb.TypeB:
    b = b1 - b2
    return b
```

とすれば、このように書ける。(先頭引数の型しか見ていないので注意)
```python
func1(a1, a2)
func1(b1, b2)
func2(a1, a2)
func2(b1, b2)
```

先頭引数以外の型も見たいのであれば、[multipledispatch](https://github.com/mrocklin/multipledispatch)をインストールすれば可能。実行例は上と同じ。
```python
from multipledispatch import dispatch

@dispatch()
def func1(a1: modulea.TypeA, a2: modulea.TypeA) -> modulea.TypeA:
    a = a1 + a2
    return a
@dispatch()
def func1(b1: moduleb.TypeB, b2: moduleb.TypeB) -> moduleb.TypeB:
    b = b1 + b2
    return b
@dispatch()
def func2(a1: modulea.TypeA, a2: modulea.TypeA) -> modulea.TypeA:
    a = a1 - a2
    return a
@dispatch()
def func2(b: moduleb.TypeB, b2: moduleb.TypeB) -> moduleb.TypeB:
    b = b1 - b2
    return b
```

Answer

質問文の例だとこれでいい気がするのですがどうでしょう

```python
import numpy as np


def add(a,b):
    return a+b

A = np.ones(3)
B = 2 * np.ones(3)

print(add(A,B)) # [3. 3. 3.]


a = 1
b = 2

print(add(a,b)) # 3
```

関連した質問