问题描述：

如何在 Python 中向现有对象（即不在类定义中）添加方法？

我理解，除了某些情况外，这样做一般不被认为是一种好的做法。

解决方案 1：

在 Python 中，函数和绑定方法之间存在差异。

>>> def foo():
...     print "foo"
...
>>> class A:
...     def bar( self ):
...         print "bar"
...
>>> a = A()
>>> foo
<function foo at 0x00A98D70>
>>> a.bar
<bound method A.bar of <__main__.A instance at 0x00A9BC88>>
>>>

绑定方法已经“绑定”（描述性如何）到某个实例，并且每当调用该方法时，该实例将作为第一个参数传递。

但是，作为类的属性（而不是实例）的可调用函数仍然不受绑定，因此您可以随时修改类定义：

>>> def fooFighters( self ):
...     print "fooFighters"
...
>>> A.fooFighters = fooFighters
>>> a2 = A()
>>> a2.fooFighters
<bound method A.fooFighters of <__main__.A instance at 0x00A9BEB8>>
>>> a2.fooFighters()
fooFighters

先前定义的实例也会被更新（只要它们自己没有覆盖属性）：

>>> a.fooFighters()
fooFighters

当你想将一个方法附加到单个实例时，问题就出现了：

>>> def barFighters( self ):
...     print "barFighters"
...
>>> a.barFighters = barFighters
>>> a.barFighters()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: barFighters() takes exactly 1 argument (0 given)

当函数直接附加到实例时，不会自动绑定：

>>> a.barFighters
<function barFighters at 0x00A98EF0>

为了绑定它，我们可以使用类型模块中的 MethodType 函数：

>>> import types
>>> a.barFighters = types.MethodType( barFighters, a )
>>> a.barFighters
<bound method ?.barFighters of <__main__.A instance at 0x00A9BC88>>
>>> a.barFighters()
barFighters

这次该类的其他实例没有受到影响：

>>> a2.barFighters()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: A instance has no attribute 'barFighters'

通过阅读描述符和元类 编程可以找到更多信息。

解决方案 2：

前言 - 关于兼容性的说明：其他答案可能只在 Python 2 中有效 - 这个答案应该在 Python 2 和 3 中完美运行。如果只编写 Python 3，您可能会省略明确继承object，但除此之外代码应该保持不变。

向现有对象实例添加方法

我读到过，在 Python 中可以向现有对象（例如不在类定义中）添加方法。

我知道这样做并不总是一个好决定。但是，我们该怎么做呢？

是的，可以——但不建议

我不推荐这样做。这是个坏主意。不要这么做。

原因如下：

• 您将为每个执行此操作的实例添加一个绑定对象。如果您经常这样做，您可能会浪费大量内存。绑定方法通常仅在其调用的短时间内创建，然后在自动垃圾回收时不复存在。如果您手动执行此操作，您将拥有一个引用绑定方法的名称绑定 - 这将阻止其在使用时进行垃圾回收。

• 给定类型的对象实例通常在该类型的所有对象上都具有其方法。如果您在其他地方添加方法，则某些实例将具有这些方法，而其他实例则不会。程序员不会预料到这种情况，并且您可能会违反最小惊喜规则。

• 由于还有其他很好的理由不这样做，如果你这样做，你还会给自己带来坏名声。

因此，我建议你不要这样做，除非你有非常好的理由。最好在类定义中定义正确的方法，或者不太好的是直接对类进行 monkey-patch，如下所示：

Foo.sample_method = sample_method

然而，因为它具有启发性，所以我将向您展示一些方法。

如何实现

这是一些设置代码。我们需要一个类定义。它可以被导入，但这真的不重要。

class Foo(object):
    '''An empty class to demonstrate adding a method to an instance'''

创建实例：

foo = Foo()

创建一个方法来添加它：

def sample_method(self, bar, baz):
    print(bar + baz)

方法 nought（0）- 使用描述符方法，__get__

函数上的点式查找使用__get__实例调用函数的方法，将对象绑定到方法，从而创建“绑定方法”。

foo.sample_method = sample_method.__get__(foo)

现在：

>>> foo.sample_method(1,2)
3

方法一 - types.MethodType

首先，导入类型，从中我们将获得方法构造函数：

import types

现在我们将方法添加到实例中。为此，我们需要来自模块types（我们上面导入的）的 MethodType 构造函数。

types.MethodType 的参数签名（在 Python 3 中）是(function, instance)：

foo.sample_method = types.MethodType(sample_method, foo)

和用法：

>>> foo.sample_method(1,2)
3

顺便说一下，在 Python 2 中签名为(function, instance, class)：

foo.sample_method = types.MethodType(sample_method, foo, Foo)

方法二：词汇绑定

首先，我们创建一个包装函数，将方法绑定到实例：

def bind(instance, method):
    def binding_scope_fn(*args, **kwargs): 
        return method(instance, *args, **kwargs)
    return binding_scope_fn

用法：

>>> foo.sample_method = bind(foo, sample_method)    
>>> foo.sample_method(1,2)
3

方法三：functools.partial

部分函数将第一个参数（以及可选的关键字参数）应用于函数，稍后可以使用其余参数（以及覆盖关键字参数）进行调用。因此：

>>> from functools import partial
>>> foo.sample_method = partial(sample_method, foo)
>>> foo.sample_method(1,2)
3    

当您认为绑定方法是实例的部分函数时，这很有意义。

未绑定函数作为对象属性-为什么这不起作用：

如果我们尝试以与将其添加到类中相同的方式添加 sample_method，它将与实例解除绑定，并且不会将隐式 self 作为第一个参数。

>>> foo.sample_method = sample_method
>>> foo.sample_method(1,2)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: sample_method() takes exactly 3 arguments (2 given)

我们可以通过显式传递实例（或任何东西，因为此方法实际上并不使用self参数变量）来使未绑定函数工作，但它与其他实例的预期签名不一致（如果我们对此实例进行 monkey-patching ）：

>>> foo.sample_method(foo, 1, 2)
3

结论

现在你知道了几种可以做到这一点的方法，但严肃地说 - 不要这样做。

解决方案 3：

从 Python 2.6 开始，模块new已被弃用，并在 Python 3.0 中被删除，请使用类型

请参阅http://docs.python.org/library/new.html

在下面的例子中，我故意从patch_me()函数中删除了返回值。我认为给出返回值可能会让人相信 patch 返回了一个新对象，但事实并非如此 - 它修改了传入的对象。这可能有助于更规范地使用 monkeypatching。

import types

class A(object):#but seems to work for old style objects too
    pass

def patch_me(target):
    def method(target,x):
        print "x=",x
        print "called from", target
    target.method = types.MethodType(method,target)
    #add more if needed

a = A()
print a
#out: <__main__.A object at 0x2b73ac88bfd0>  
patch_me(a)    #patch instance
a.method(5)
#out: x= 5
#out: called from <__main__.A object at 0x2b73ac88bfd0>
patch_me(A)
A.method(6)        #can patch class too
#out: x= 6
#out: called from <class '__main__.A'>

解决方案 4：

我觉得上面的回答都没有抓住重点。

让我们有一个带有方法的类：

class A(object):
    def m(self):
        pass

现在，让我们在 ipython 中玩一下：

In [2]: A.m
Out[2]: <unbound method A.m>

好的，所以m()不知何故成为了A的非绑定方法。但事实真的是这样吗？

In [5]: A.__dict__['m']
Out[5]: <function m at 0xa66b8b4>

事实证明，m()只是一个函数，对它的引用被添加到A类字典中 - 没有什么神奇之处。那么为什么Am给我们一个未绑定的方法呢？这是因为点没有被转换成简单的字典查找。它实际上是对 A.__class__.__getattribute__(A, 'm') 的调用：

In [11]: class MetaA(type):
   ....:     def __getattribute__(self, attr_name):
   ....:         print str(self), '-', attr_name

In [12]: class A(object):
   ....:     __metaclass__ = MetaA

In [23]: A.m
<class '__main__.A'> - m
<class '__main__.A'> - m

现在，我还不清楚为什么最后一行会打印两次，但仍然清楚发生了什么。

现在，默认的 getattribute 所做的是检查属性是否是所谓的描述符，即它是否实现了特殊的 get 方法。如果它实现了该方法，则返回的是调用该 get 方法的结果。回到我们的A类的第一个版本，这就是我们所拥有的：

In [28]: A.__dict__['m'].__get__(None, A)
Out[28]: <unbound method A.m>

并且由于 Python 函数实现了描述符协议，如果它们代表某个对象被调用，它们就会在其 get 方法中将自身绑定到该对象。

好的，那么如何向现有对象添加方法？假设您不介意修补类，那么很简单：

B.m = m

然后，由于描述符的魔力，Bm “变成”了一个不受绑定的方法。

如果你只想向单个对象添加方法，那么你必须自己使用 types.MethodType 来模拟机制：

b.m = types.MethodType(m, b)

顺便一提：

In [2]: A.m
Out[2]: <unbound method A.m>

In [59]: type(A.m)
Out[59]: <type 'instancemethod'>

In [60]: type(b.m)
Out[60]: <type 'instancemethod'>

In [61]: types.MethodType
Out[61]: <type 'instancemethod'>

解决方案 5：

在 Python 中，monkeypatching 通常通过使用自己的签名覆盖类或函数的签名来实现。以下是来自Zope Wiki的一个示例：

from SomeOtherProduct.SomeModule import SomeClass
def speak(self):
   return "ook ook eee eee eee!"
SomeClass.speak = speak

此代码将覆盖/创建类中调用的方法speak。在 Jeff Atwood最近关于 monkey patching 的帖子中，他展示了一个 C# 3.0 中的示例，这是我目前工作中使用的语言。

解决方案 6：

您可以使用 lambda 将方法绑定到实例：

def run(self):
    print self._instanceString

class A(object):
    def __init__(self):
        self._instanceString = "This is instance string"

a = A()
a.run = lambda: run(a)
a.run()

输出：

This is instance string

解决方案 7：

我相信您正在寻找setattr。使用它来设置对象的属性。

>>> def printme(s): print repr(s)
>>> class A: pass
>>> setattr(A,'printme',printme)
>>> a = A()
>>> a.printme() # s becomes the implicit 'self' variable
< __ main __ . A instance at 0xABCDEFG>

解决方案 8：

至少有两种方式可以将方法附加到没有的实例types.MethodType：

>>> class A:
...  def m(self):
...   print 'im m, invoked with: ', self

>>> a = A()
>>> a.m()
im m, invoked with:  <__main__.A instance at 0x973ec6c>
>>> a.m
<bound method A.m of <__main__.A instance at 0x973ec6c>>
>>> 
>>> def foo(firstargument):
...  print 'im foo, invoked with: ', firstargument

>>> foo
<function foo at 0x978548c>

1：

>>> a.foo = foo.__get__(a, A) # or foo.__get__(a, type(a))
>>> a.foo()
im foo, invoked with:  <__main__.A instance at 0x973ec6c>
>>> a.foo
<bound method A.foo of <__main__.A instance at 0x973ec6c>>

2：

>>> instancemethod = type(A.m)
>>> instancemethod
<type 'instancemethod'>
>>> a.foo2 = instancemethod(foo, a, type(a))
>>> a.foo2()
im foo, invoked with:  <__main__.A instance at 0x973ec6c>
>>> a.foo2
<bound method instance.foo of <__main__.A instance at 0x973ec6c>>

有用的链接：

数据模型 - 调用描述符

描述符操作指南 - 调用描述符

解决方案 9：

整合 Jason Pratt 和社区维基的答案，并查看不同绑定方法的结果：

特别注意添加绑定函数作为类方法的工作原理，但引用范围不正确。

#!/usr/bin/python -u
import types
import inspect

## dynamically adding methods to a unique instance of a class


# get a list of a class's method type attributes
def listattr(c):
    for m in [(n, v) for n, v in inspect.getmembers(c, inspect.ismethod) if isinstance(v,types.MethodType)]:
        print m[0], m[1]

# externally bind a function as a method of an instance of a class
def ADDMETHOD(c, method, name):
    c.__dict__[name] = types.MethodType(method, c)

class C():
    r = 10 # class attribute variable to test bound scope

    def __init__(self):
        pass

    #internally bind a function as a method of self's class -- note that this one has issues!
    def addmethod(self, method, name):
        self.__dict__[name] = types.MethodType( method, self.__class__ )

    # predfined function to compare with
    def f0(self, x):
        print 'f0    x = %d    r = %d' % ( x, self.r)

a = C() # created before modified instnace
b = C() # modified instnace


def f1(self, x): # bind internally
    print 'f1    x = %d    r = %d' % ( x, self.r )
def f2( self, x): # add to class instance's .__dict__ as method type
    print 'f2    x = %d    r = %d' % ( x, self.r )
def f3( self, x): # assign to class as method type
    print 'f3    x = %d    r = %d' % ( x, self.r )
def f4( self, x): # add to class instance's .__dict__ using a general function
    print 'f4    x = %d    r = %d' % ( x, self.r )


b.addmethod(f1, 'f1')
b.__dict__['f2'] = types.MethodType( f2, b)
b.f3 = types.MethodType( f3, b)
ADDMETHOD(b, f4, 'f4')


b.f0(0) # OUT: f0   x = 0   r = 10
b.f1(1) # OUT: f1   x = 1   r = 10
b.f2(2) # OUT: f2   x = 2   r = 10
b.f3(3) # OUT: f3   x = 3   r = 10
b.f4(4) # OUT: f4   x = 4   r = 10


k = 2
print 'changing b.r from {0} to {1}'.format(b.r, k)
b.r = k
print 'new b.r = {0}'.format(b.r)

b.f0(0) # OUT: f0   x = 0   r = 2
b.f1(1) # OUT: f1   x = 1   r = 10  !!!!!!!!!
b.f2(2) # OUT: f2   x = 2   r = 2
b.f3(3) # OUT: f3   x = 3   r = 2
b.f4(4) # OUT: f4   x = 4   r = 2

c = C() # created after modifying instance

# let's have a look at each instance's method type attributes
print '
attributes of a:'
listattr(a)
# OUT:
# attributes of a:
# __init__ <bound method C.__init__ of <__main__.C instance at 0x000000000230FD88>>
# addmethod <bound method C.addmethod of <__main__.C instance at 0x000000000230FD88>>
# f0 <bound method C.f0 of <__main__.C instance at 0x000000000230FD88>>

print '
attributes of b:'
listattr(b)
# OUT:
# attributes of b:
# __init__ <bound method C.__init__ of <__main__.C instance at 0x000000000230FE08>>
# addmethod <bound method C.addmethod of <__main__.C instance at 0x000000000230FE08>>
# f0 <bound method C.f0 of <__main__.C instance at 0x000000000230FE08>>
# f1 <bound method ?.f1 of <class __main__.C at 0x000000000237AB28>>
# f2 <bound method ?.f2 of <__main__.C instance at 0x000000000230FE08>>
# f3 <bound method ?.f3 of <__main__.C instance at 0x000000000230FE08>>
# f4 <bound method ?.f4 of <__main__.C instance at 0x000000000230FE08>>

print '
attributes of c:'
listattr(c)
# OUT:
# attributes of c:
# __init__ <bound method C.__init__ of <__main__.C instance at 0x0000000002313108>>
# addmethod <bound method C.addmethod of <__main__.C instance at 0x0000000002313108>>
# f0 <bound method C.f0 of <__main__.C instance at 0x0000000002313108>>

就我个人而言，我更喜欢外部 ADDMETHOD 函数路由，因为它允许我在迭代器中动态分配新的方法名称。

def y(self, x):
    pass
d = C()
for i in range(1,5):
    ADDMETHOD(d, y, 'f%d' % i)
print '
attributes of d:'
listattr(d)
# OUT:
# attributes of d:
# __init__ <bound method C.__init__ of <__main__.C instance at 0x0000000002303508>>
# addmethod <bound method C.addmethod of <__main__.C instance at 0x0000000002303508>>
# f0 <bound method C.f0 of <__main__.C instance at 0x0000000002303508>>
# f1 <bound method ?.y of <__main__.C instance at 0x0000000002303508>>
# f2 <bound method ?.y of <__main__.C instance at 0x0000000002303508>>
# f3 <bound method ?.y of <__main__.C instance at 0x0000000002303508>>
# f4 <bound method ?.y of <__main__.C instance at 0x0000000002303508>>

解决方案 10：

由于这个问题要求非 Python 版本，因此这里是 JavaScript：

a.methodname = function () { console.log("Yay, a new method!") }

解决方案 11：

这实际上是“Jason Pratt”答案的附加内容

虽然 Jason 的答案有效，但它只在想要向类添加函数时才有效。当我尝试从 .py 源代码文件重新加载已经存在的方法时，它对我不起作用。

我花了很长时间才找到一个解决方法，但这个技巧看起来很简单...... 1. 从源代码文件导入代码 2. 强制重新加载 3. 使用 types.FunctionType(...) 将导入和绑定的方法转换为函数您还可以传递当前全局变量，因为重新加载的方法将位于不同的命名空间中 4. 现在您可以按照“Jason Pratt”的建议继续使用 types.MethodType(...)

例子：

# this class resides inside ReloadCodeDemo.py
class A:
    def bar( self ):
        print "bar1"
        
    def reloadCode(self, methodName):
        ''' use this function to reload any function of class A'''
        import types
        import ReloadCodeDemo as ReloadMod # import the code as module
        reload (ReloadMod) # force a reload of the module
        myM = getattr(ReloadMod.A,methodName) #get reloaded Method
        myTempFunc = types.FunctionType(# convert the method to a simple function
                                myM.im_func.func_code, #the methods code
                                globals(), # globals to use
                                argdefs=myM.im_func.func_defaults # default values for variables if any
                                ) 
        myNewM = types.MethodType(myTempFunc,self,self.__class__) #convert the function to a method
        setattr(self,methodName,myNewM) # add the method to the function

if __name__ == '__main__':
    a = A()
    a.bar()
    # now change your code and save the file
    a.reloadCode('bar') # reloads the file
    a.bar() # now executes the reloaded code

解决方案 12：

这个问题是几年前提出的，但是，有一个简单的方法可以使用装饰器模拟函数与类实例的绑定：

def binder (function, instance):
  copy_of_function = type (function) (function.func_code, {})
  copy_of_function.__bind_to__ = instance
  def bound_function (*args, **kwargs):
    return copy_of_function (copy_of_function.__bind_to__, *args, **kwargs)
  return bound_function


class SupaClass (object):
  def __init__ (self):
    self.supaAttribute = 42


def new_method (self):
  print self.supaAttribute


supaInstance = SupaClass ()
supaInstance.supMethod = binder (new_method, supaInstance)

otherInstance = SupaClass ()
otherInstance.supaAttribute = 72
otherInstance.supMethod = binder (new_method, otherInstance)

otherInstance.supMethod ()
supaInstance.supMethod ()

在那里，当您将函数和实例传递给绑定器装饰器时，它将创建一个新函数，其代码对象与第一个函数相同。然后，​​给定的类实例存储在新创建的函数的属性中。装饰器返回一个（第三个）函数，该函数自动调用复制的函数，并将实例作为第一个参数。

最后，您将获得一个模拟其与类实例绑定的函数。保持原始函数不变。

解决方案 13：

我觉得很奇怪，没有人提到上面列出的所有方法都会在添加的方法和实例之间创建循环引用，从而导致对象一直存在直到垃圾收集。有一个老办法，通过扩展对象的类来添加描述符：

def addmethod(obj, name, func):
    klass = obj.__class__
    subclass = type(klass.__name__, (klass,), {})
    setattr(subclass, name, func)
    obj.__class__ = subclass

解决方案 14：

如果能有所帮助的话，我最近发布了一个名为 Gorilla 的 Python 库，以使 monkey patching 的过程更加方便。

使用函数needle()来修补名为 goes 的模块guineapig如下：

import gorilla
import guineapig
@gorilla.patch(guineapig)
def needle():
    print("awesome")

但它还处理更多有趣的用例，如文档中的常见问题解答中所示。

该代码可在GitHub上获取。

解决方案 15：

from types import MethodType

def method(self):
   print 'hi!'


setattr( targetObj, method.__name__, MethodType(method, targetObj, type(method)) )

有了这个，你可以使用自指针

解决方案 16：

Jason Pratt 所发布的内容是正确的。

>>> class Test(object):
...   def a(self):
...     pass
... 
>>> def b(self):
...   pass
... 
>>> Test.b = b
>>> type(b)
<type 'function'>
>>> type(Test.a)
<type 'instancemethod'>
>>> type(Test.b)
<type 'instancemethod'>

如您所见，Python 并不认为 b() 与 a() 有任何不同。在 Python 中，所有方法都只是碰巧是函数的变量。

解决方案 17：

如何从类的实例中恢复类

class UnderWater:
    def __init__(self):
        self.net = 'underwater'

marine = UnderWater() # Instantiate the class

# Recover the class from the instance and add attributes to it.
class SubMarine(marine.__class__):  
    def __init__(self):
        super().__init__()
            self.sound = 'Sonar'
    
print(SubMarine, SubMarine.__name__, SubMarine().net, SubMarine().sound)

# Output
# (__main__.SubMarine,'SubMarine', 'underwater', 'Sonar')

解决方案 18：

除了其他人所说的之外，我发现__repr__和__str__方法不能在对象级别进行 monkeypatched，因为repr()和str()使用类方法，而不是局部有界的对象方法：

# Instance monkeypatch
[ins] In [55]: x.__str__ = show.__get__(x)                                                                 

[ins] In [56]: x                                                                                           
Out[56]: <__main__.X at 0x7fc207180c10>

[ins] In [57]: str(x)                                                                                      
Out[57]: '<__main__.X object at 0x7fc207180c10>'

[ins] In [58]: x.__str__()                                                                                 
Nice object!

# Class monkeypatch
[ins] In [62]: X.__str__ = lambda _: "From class"                                                          

[ins] In [63]: str(x)                                                                                      
Out[63]: 'From class'

解决方案 19：

感谢 Arturo！您的回答让我走上了正确的道路！

根据 Arturo 的代码，我编写了一个小类：

from types import MethodType
import re
from string import ascii_letters


class DynamicAttr:
    def __init__(self):
        self.dict_all_files = {}

    def _copy_files(self, *args, **kwargs):
        print(f'copy {args[0]["filename"]} {args[0]["copy_command"]}')

    def _delete_files(self, *args, **kwargs):
        print(f'delete {args[0]["filename"]} {args[0]["delete_command"]}')

    def _create_properties(self):
        for key, item in self.dict_all_files.items():
            setattr(
                self,
                key,
                self.dict_all_files[key],
            )
            setattr(
                self,
                key + "_delete",
                MethodType(
                    self._delete_files,
                    {
                        "filename": key,
                        "delete_command": f'del {item}',
                    },
                ),
            )
            setattr(
                self,
                key + "_copy",
                MethodType(
                    self._copy_files,
                    {
                        "filename": key,
                        "copy_command": f'copy {item}',
                    },
                ),
            )
    def add_files_to_class(self, filelist: list):
        for _ in filelist:
            attr_key = re.sub(rf'[^{ascii_letters}]+', '_', _).strip('_')
            self.dict_all_files[attr_key] = _
        self._create_properties()
dy = DynamicAttr()
dy.add_files_to_class([r"C:Windows
otepad.exe", r"C:Windows
egedit.exe"])

dy.add_files_to_class([r"C:WindowsHelpPane.exe", r"C:Windowswin.ini"])
#output
print(dy.C_Windows_HelpPane_exe)
dy.C_Windows_notepad_exe_delete()
dy.C_Windows_HelpPane_exe_copy()
C:WindowsHelpPane.exe
delete C_Windows_notepad_exe del C:Windows
otepad.exe
copy C_Windows_HelpPane_exe copy C:WindowsHelpPane.exe

此类允许您随时添加新的属性和方法。

编辑：

这是一个更加通用的解决方案：

import inspect
import re
from copy import deepcopy
from string import ascii_letters


def copy_func(f):
    if callable(f):
        if inspect.ismethod(f) or inspect.isfunction(f):
            g = lambda *args, **kwargs: f(*args, **kwargs)
            t = list(filter(lambda prop: not ("__" in prop), dir(f)))
            i = 0
            while i < len(t):
                setattr(g, t[i], getattr(f, t[i]))
                i += 1
            return g
    dcoi = deepcopy([f])
    return dcoi[0]


class FlexiblePartial:
    def __init__(self, func, this_args_first, *args, **kwargs):

        try:
            self.f = copy_func(func)  # create a copy of the function
        except Exception:
            self.f = func
        self.this_args_first = this_args_first  # where should the other (optional) arguments be that are passed when the function is called
        try:
            self.modulename = args[0].__class__.__name__  # to make repr look good
        except Exception:
            self.modulename = "self"

        try:
            self.functionname = func.__name__  # to make repr look good
        except Exception:
            try:
                self.functionname = func.__qualname__  # to make repr look good
            except Exception:
                self.functionname = "func"

        self.args = args
        self.kwargs = kwargs

        self.name_to_print = self._create_name()  # to make repr look good

    def _create_name(self):
        stra = self.modulename + "." + self.functionname + "(self, "
        for _ in self.args[1:]:
            stra = stra + repr(_) + ", "
        for key, item in self.kwargs.items():
            stra = stra + str(key) + "=" + repr(item) + ", "
        stra = stra.rstrip().rstrip(",")
        stra += ")"
        if len(stra) > 100:
            stra = stra[:95] + "...)"
        return stra

    def __call__(self, *args, **kwargs):
        newdic = {}
        newdic.update(self.kwargs)
        newdic.update(kwargs)
        if self.this_args_first:
            return self.f(*self.args[1:], *args, **newdic)

        else:

            return self.f(*args, *self.args[1:], **newdic)

    def __str__(self):
        return self.name_to_print

    def __repr__(self):
        return self.__str__()


class AddMethodsAndProperties:
    def add_methods(self, dict_to_add):
        for key_, item in dict_to_add.items():
            key = re.sub(rf"[^{ascii_letters}]+", "_", str(key_)).rstrip("_")
            if isinstance(item, dict):
                if "function" in item:  # for adding methods
                    if not isinstance(
                        item["function"], str
                    ):  # for external functions that are not part of the class
                        setattr(
                            self,
                            key,
                            FlexiblePartial(
                                item["function"],
                                item["this_args_first"],
                                self,
                                *item["args"],
                                **item["kwargs"],
                            ),
                        )

                    else:
                        setattr(
                            self,
                            key,
                            FlexiblePartial(
                                getattr(
                                    self, item["function"]
                                ),  # for internal functions - part of the class
                                item["this_args_first"],
                                self,
                                *item["args"],
                                **item["kwargs"],
                            ),
                        )
            else:  # for adding props
                setattr(self, key, item)

我们来测试一下：

class NewClass(AddMethodsAndProperties): #inherit from AddMethodsAndProperties to add the method add_methods
    def __init__(self):
        self.bubu = 5

    def _delete_files(self, file): #some random methods 
        print(f"File will be deleted: {file}")

    def delete_files(self, file):
        self._delete_files(file)

    def _copy_files(self, file, dst):
        print(f"File will be copied: {file} Dest: {dst}")

    def copy_files(self, file, dst):
        self._copy_files(file, dst)

    def _create_files(self, file, folder):
        print(f"File will be created: {file} {folder}")

    def create_files(self, file, folder):
        self._create_files(file, folder)

    def method_with_more_kwargs(self, file, folder, one_more):
        print(file, folder, one_more)
        return self


nc = NewClass()
dict_all_files = {
    r"C:Windows
otepad.exe_delete": {
        "function": "delete_files",
        "args": (),
        "kwargs": {"file": r"C:Windows
otepad.exe"},
        "this_args_first": True,
    },
    r"C:Windows
otepad.exe_argsfirst": {
        "function": "delete_files",
        "args": (),
        "kwargs": {"file": r"C:Windows
otepad.exe"},
        "this_args_first": True,
    },
    r"C:Windows
otepad.exe_copy": {
        "function": "copy_files",
        "args": (),
        "kwargs": {
            "file": r"C:Windows
otepad.exe",
            "dst": r"C:Windows
otepad555.exe",
        },
        "this_args_first": True,
    },
    r"C:Windows
otepad.exe_create": {
        "function": "create_files",
        "args": (),
        "kwargs": {"file": r"C:Windows
otepad.exe", "folder": "c:\\windows95"},
        "this_args_first": True,
    },
    r"C:Windows
otepad.exe_upper": {
        "function": str.upper,
        "args": (r"C:Windows
otepad.exe",),
        "kwargs": {},
        "this_args_first": True,
    },
    r"C:Windows
otepad.exe_method_with_more_kwargs": {
        "function": "method_with_more_kwargs",
        "args": (),
        "kwargs": {"file": r"C:Windows
otepad.exe", "folder": "c:\\windows95"},
        "this_args_first": True,
    },
    r"C:Windows
otepad.exe_method_with_more_kwargs_as_args_first": {
        "function": "method_with_more_kwargs",
        "args": (r"C:Windows
otepad.exe", "c:\\windows95"),
        "kwargs": {},
        "this_args_first": True,
    },
    r"C:Windows
otepad.exe_method_with_more_kwargs_as_args_last": {
        "function": "method_with_more_kwargs",
        "args": (r"C:Windows
otepad.exe", "c:\\windows95"),
        "kwargs": {},
        "this_args_first": False,
    },
    "this_is_a_list": [55, 3, 3, 1, 4, 43],
}

nc.add_methods(dict_all_files)


print(nc.C_Windows_notepad_exe_delete)
print(nc.C_Windows_notepad_exe_delete(), end="

")
print(nc.C_Windows_notepad_exe_argsfirst)
print(nc.C_Windows_notepad_exe_argsfirst(), end="

")
print(nc.C_Windows_notepad_exe_copy)
print(nc.C_Windows_notepad_exe_copy(), end="

")
print(nc.C_Windows_notepad_exe_create)
print(nc.C_Windows_notepad_exe_create(), end="

")
print(nc.C_Windows_notepad_exe_upper)
print(nc.C_Windows_notepad_exe_upper(), end="

")
print(nc.C_Windows_notepad_exe_method_with_more_kwargs)
print(
    nc.C_Windows_notepad_exe_method_with_more_kwargs(
        one_more="f:\\blaaaaaaaaaaaaaaaaaaaaaaaa"
    )
    .C_Windows_notepad_exe_method_with_more_kwargs(
        one_more="f:\\ASJVASDFASÇDFJASÇDJFÇASWFJASÇ"
    )
    .C_Windows_notepad_exe_method_with_more_kwargs(
        one_more="f:\\XXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
    ),
    end="

",
)
print(nc.C_Windows_notepad_exe_method_with_more_kwargs_as_args_first)
print(
    nc.C_Windows_notepad_exe_method_with_more_kwargs_as_args_first(
        "f:\\blaaaaaaaaaaaaaaaaaaaaaaaa"
    ),
    end="

",
)
print(
    nc.C_Windows_notepad_exe_method_with_more_kwargs_as_args_first(
        "f:\\blaaaaaaaaaaaaaaaaaaaaaaaa"
    )
    .C_Windows_notepad_exe_method_with_more_kwargs_as_args_first(
        "f:\\ASJVASDFASÇDFJASÇDJFÇASWFJASÇ"
    )
    .C_Windows_notepad_exe_method_with_more_kwargs_as_args_first(
        "f:\\XXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
    ),
    end="

",
)
print(nc.C_Windows_notepad_exe_method_with_more_kwargs_as_args_last)
print(
    nc.C_Windows_notepad_exe_method_with_more_kwargs_as_args_last(
        "f:\\blaaaaaaaaaaaaaaaaaaaaaaaa"
    )
    .C_Windows_notepad_exe_method_with_more_kwargs_as_args_last(
        "f:\\ASJVASDFASÇDFJASÇDJFÇASWFJASÇ"
    )
    .C_Windows_notepad_exe_method_with_more_kwargs_as_args_last(
        "f:\\XXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
    ),
    end="

",
)
print(
    nc.C_Windows_notepad_exe_method_with_more_kwargs_as_args_last(
        "f:\\blaaaaaaaaaaaaaaaaaaaaaaaa"
    )
    .C_Windows_notepad_exe_method_with_more_kwargs_as_args_last(
        "f:\\ASJVASDFASÇDFJASÇDJFÇASWFJASÇ"
    )
    .C_Windows_notepad_exe_method_with_more_kwargs_as_args_last(
        "f:\\XXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
    ),
    end="

",
)
print(nc.this_is_a_list)
checkit = (
    nc.C_Windows_notepad_exe_method_with_more_kwargs_as_args_last(
        "f:\\blaaaaaaaaaaaaaaaaaaaaaaaa"
    )
    .C_Windows_notepad_exe_method_with_more_kwargs_as_args_last(
        "f:\\ASJVASDFASÇDFJASÇDJFÇASWFJASÇ"
    )
    .C_Windows_notepad_exe_method_with_more_kwargs_as_args_last(
        "f:\\XXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
    )
)
print(f'nc is checkit? -> {nc is checkit}')


#output:


NewClass.delete_files(self, file='C:\\Windows\\notepad.exe')
File will be deleted: C:Windows
otepad.exe
None


NewClass.delete_files(self, file='C:\\Windows\\notepad.exe')
File will be deleted: C:Windows
otepad.exe
None


NewClass.copy_files(self, file='C:\\Windows\\notepad.exe', dst='C:\\Windows\\notepad555.exe')
File will be copied: C:Windows
otepad.exe Dest: C:Windows
otepad555.exe
None


NewClass.create_files(self, file='C:\\Windows\\notepad.exe', folder='c:\\windows95')
File will be created: C:Windows
otepad.exe c:windows95
None


NewClass.upper(self, 'C:\\Windows\\notepad.exe')
C:WINDOWSNOTEPAD.EXE


NewClass.method_with_more_kwargs(self, file='C:\\Windows\\notepad.exe', folder='c:\\windows95')
C:Windows
otepad.exe c:windows95 f:laaaaaaaaaaaaaaaaaaaaaaaa
C:Windows
otepad.exe c:windows95 f:ASJVASDFASÇDFJASÇDJFÇASWFJASÇ
C:Windows
otepad.exe c:windows95 f:XXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
<__main__.NewClass object at 0x0000000005F199A0>


NewClass.method_with_more_kwargs(self, 'C:\\Windows\\notepad.exe', 'c:\\windows95')
C:Windows
otepad.exe c:windows95 f:laaaaaaaaaaaaaaaaaaaaaaaa
<__main__.NewClass object at 0x0000000005F199A0>


C:Windows
otepad.exe c:windows95 f:laaaaaaaaaaaaaaaaaaaaaaaa
C:Windows
otepad.exe c:windows95 f:ASJVASDFASÇDFJASÇDJFÇASWFJASÇ
C:Windows
otepad.exe c:windows95 f:XXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
<__main__.NewClass object at 0x0000000005F199A0>


NewClass.method_with_more_kwargs(self, 'C:\\Windows\\notepad.exe', 'c:\\windows95')
f:laaaaaaaaaaaaaaaaaaaaaaaa C:Windows
otepad.exe c:windows95
f:ASJVASDFASÇDFJASÇDJFÇASWFJASÇ C:Windows
otepad.exe c:windows95
f:XXXXXXXXXXXXXXXXXXXXXXXXXXXXXX C:Windows
otepad.exe c:windows95
<__main__.NewClass object at 0x0000000005F199A0>


f:laaaaaaaaaaaaaaaaaaaaaaaa C:Windows
otepad.exe c:windows95
f:ASJVASDFASÇDFJASÇDJFÇASWFJASÇ C:Windows
otepad.exe c:windows95
f:XXXXXXXXXXXXXXXXXXXXXXXXXXXXXX C:Windows
otepad.exe c:windows95
<__main__.NewClass object at 0x0000000005F199A0>


[55, 3, 3, 1, 4, 43]


f:laaaaaaaaaaaaaaaaaaaaaaaa C:Windows
otepad.exe c:windows95
f:ASJVASDFASÇDFJASÇDJFÇASWFJASÇ C:Windows
otepad.exe c:windows95
f:XXXXXXXXXXXXXXXXXXXXXXXXXXXXXX C:Windows
otepad.exe c:windows95


nc is checkit? -> True