如何在 Python 中对函数进行深度复制？

Question

我想在 Python 中制作一个函数的深度复制。根据文档，copy模块没有帮助，其中说：

该模块不复制模块、方法、堆栈跟踪、堆栈帧、文件等类型， 套接字、窗口、数组或任何类似的类型。它确实“复制”函数和类（浅层 并深入），通过不变地返回原始对象；这与方式兼容 这些由 pickle 模块处理。

我的目标是拥有两个具有相同实现但具有不同文档字符串的函数。

def A():
    """A"""
    pass

B = make_a_deepcopy_of(A)
B.__doc__ = """B"""

那么如何才能做到这一点呢？

Answer 1

FunctionType 构造函数用于制作函数的深层复制。

import types
def copy_func(f, name=None):
    return types.FunctionType(f.func_code, f.func_globals, name or f.func_name,
        f.func_defaults, f.func_closure)

def A():
    """A"""
    pass
B = copy_func(A, "B")
B.__doc__ = """B"""

Answer 2

我的目标是拥有两个具有相同实现但具有不同文档字符串的函数。

大多数用户都会这样做，假设原始函数在 old_module.py 中：

def implementation(arg1, arg2): 
    """this is a killer function"""

而在 new_module.py 中，

from old_module import implementation as _implementation

def implementation(arg1, arg2):
    """a different docstring"""
    return _implementation(arg1, arg2)

这是重用功能的最直接的方法。很容易阅读和理解意图。

尽管如此，也许你对你的主要问题有充分的理由：

如何在 Python 中制作函数的深层复制？

为了保持与 Python 2和 3 的兼容性，我建议使用该函数的特殊 __dunder__ 属性。例如：

import types

def copy_func(f, name=None):
    '''
    return a function with same code, globals, defaults, closure, and 
    name (or provide a new name)
    '''
    fn = types.FunctionType(f.__code__, f.__globals__, name or f.__name__,
        f.__defaults__, f.__closure__)
    # in case f was given attrs (note this dict is a shallow copy):
    fn.__dict__.update(f.__dict__) 
    return fn

这是一个示例用法：

def main():
    from logging import getLogger as _getLogger # pyflakes:ignore, must copy
    getLogger = copy_func(_getLogger)
    getLogger.__doc__ += '\n    This function is from the Std Lib logging module.\n    '
    assert getLogger.__doc__ is not _getLogger.__doc__
    assert getLogger.__doc__ != _getLogger.__doc__

评论者说：

这不适用于内置函数

好吧，我不会为内置函数这样做。对于用纯 Python 编写的函数，我没有什么理由这样做，而且我怀疑如果你这样做，你可能会做一些非常错误的事情（尽管我在这里可能是错的）。

如果您想要一个函数执行内置函数的操作，并重用实现，就像副本一样，那么您应该用另一个函数包装该函数，例如：

_sum = sum
def sum(iterable, start=0):
    """sum function that works like the regular sum function, but noisy"""
    print('calling the sum function')
    return _sum(iterable, start)
    

Answer 3

from functools import partial

def a():
    """Returns 1"""
    return 1

b = partial(a)
b.__doc__ = """Returns 1, OR DOES IT!"""

print help(a)
print help(b)

将其包裹为部分？

Answer 4

def A():
    """A"""
    pass

def B():
    """B"""
    return A()

Answer 5

其他答案不允许使用pickle进行序列化。这里是我用来克隆函数并允许 python3 序列化的代码：

import pickle
import dill
import types

def foo():
    print ('a')


oldCode=foo.__code__

name='IAmFooCopied'

newCode= types.CodeType(
        oldCode.co_argcount,             #   integer
        oldCode.co_kwonlyargcount,       #   integer
        oldCode.co_nlocals,              #   integer
        oldCode.co_stacksize,            #   integer
        oldCode.co_flags,                #   integer
        oldCode.co_code,                 #   bytes
        oldCode.co_consts,               #   tuple
        oldCode.co_names,                #   tuple
        oldCode.co_varnames,             #   tuple
        oldCode.co_filename,             #   string
        name,                  #   string
        oldCode.co_firstlineno,          #   integer
        oldCode.co_lnotab,               #   bytes
        oldCode.co_freevars,             #   tuple
        oldCode.co_cellvars              #   tuple
        )

IAmFooCopied=types.FunctionType(newCode, foo.__globals__, name,foo.__defaults__ , foo.__closure__)
IAmFooCopied.__qualname__= name
print ( 'printing foo and the copy', IAmFooCopied, foo )
print ( 'dill output: ', dill.dumps(IAmFooCopied ))
print ( 'pickle Output: ', pickle.dumps (IAmFooCopied) )

输出：

printing foo and the copy <function IAmFooCopied at 0x7f8a6a8159d8> <function foo at 0x7f8a6b5f5268>
dill output:  b'\x80\x03cdill._dill\n_create_function\nq\x00(cdill._dill\n_load_type\nq\x01X\x08\x00\x00\x00CodeTypeq\x02\x85q\x03Rq\x04(K\x00K\x00K\x00K\x02KCC\x0ct\x00d\x01\x83\x01\x01\x00d\x00S\x00q\x05NX\x01\x00\x00\x00aq\x06\x86q\x07X\x05\x00\x00\x00printq\x08\x85q\t)X\x10\x00\x00\x00testCloneFunc.pyq\nX\x0c\x00\x00\x00IAmFooCopiedq\x0bK\x05C\x02\x00\x01q\x0c))tq\rRq\x0ec__builtin__\n__main__\nh\x0bNN}q\x0ftq\x10Rq\x11.'
pickle Output:  b'\x80\x03c__main__\nIAmFooCopied\nq\x00.'

如果您使用类方法尝试此代码片段，您可能会遇到 qualname 属性问题（我认为 pickle 应该无法找到你的函数）。我从未尝试过，但它应该很容易修复。只需检查有关 qualname 的文档即可

Answer 6

使用 lambda 和其余参数很容易做到：

def my_copy(f): 
        # Create a lambda that mimics f
        g = lambda *args: f(*args)
        # Add any properties of f
        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
        
# Test
def sqr(x): return x*x
sqr.foo = 500

sqr_copy = my_copy(sqr)
print(sqr_copy(5)) # -> 25
print(sqr_copy(6)) # -> 36
print(sqr_copy.foo) # -> 500
print(sqr_copy == sqr) # -> False

在线尝试！

Answer 7

把它放在一个函数中：

def makefunc( docstring ):
    def f():
        pass
    f.__doc__ = docstring
    return f

f = makefunc('I am f')
g = makefunc("I am f too")

Answer 8

针对 python3 进行了调整

import types
def copy_func(f, name=None):
    return types.FunctionType(f.__code__, f.__globals__, name or f.__name__,
        f.__defaults__, f.__closure__)
def func1(x):
  return 2*x
func2=copy_func(func1)
print(func2(7))

Answer 9

我在 haggis 中实现了通用函数副本，该库我编写并维护（可通过 pip 使用，但可能不可用 conda）。 haggis.objects.copy_func 制作一个副本，您不仅可以在其上重新分配 __doc__ 属性，还可以有效地修改模块和 __globals__ 属性。

from haggis.objects import copy_func

def a(*args, **kwargs):
    """A docstring"""

a2 = copy_func(a)
a2.__doc__ = """Another docstring"""

>>> a == a2
False
>>> a.__code__ == a2.__code__
True
>>> a.__doc__
'A docstring'
>>> a2.__doc__
'Another docstring'