blocks|key|3169022|text|def+A():
++++"""A"""
++++pass

def+B():
++++"""B"""
++++return+A()|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|3169023|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>def A():
 """A"""
 pass

def B():
 """B"""
 return A()
</code></pre>

blocks|key|266214|text|将其放入一个函数中：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|266215|def+makefunc(+docstring+):
++++def+f():
++++++++pass
++++f.__doc__+=+docstring
++++return+f

f+=+makefunc('I+am+f')
g+=+makefunc("I+am+f+too")|code-block|syntax|javascript|266216|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

put it in a function:

<pre><code>def makefunc( docstring ):
 def f():
 pass
 f.__doc__ = docstring
 return f

f = makefunc('I am f')
g = makefunc("I am f too")
</code></pre>

blocks|key|3169051|text|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)|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|3169052|把它包装成部分的？|unstyled|3169053|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|J|8|@]|9|@]|A|$]]|$1|G|3|-4|5|F|7|K|8|@]|9|@]|A|$]]]|H|$]]

<pre><code>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)
</code></pre>

Wrap it as a partial?

blocks|key|263015|text|FunctionType构造函数用于制作函数的深层副本。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|263016|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"""|code-block|syntax|javascript|263017|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

The FunctionType constructor is used to make a deep copy of a function.

<pre><code>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"""
</code></pre>

blocks|key|3169200|text|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3169201|我的目标是拥有两个实现相同但文档字符串不同的函数。|blockquote|3169202|3169203|3169204|大多数用户都会这样做，比如原始函数是用old_module.py编写的|offset|length|style|CODE|3169205|def+implementation(arg1,+arg2):+
++++"""this+is+a+killer+function"""|code-block|syntax|javascript|3169206|在new_module.py中|3169207|from+old_module+import+implementation+as+_implementation

def+implementation(arg1,+arg2):
++++"""a+different+docstring"""
++++return+_implementation(arg1,+arg2)|3169208|这是重用功能的最直接的方法。它很容易阅读和理解其意图。|3169209|然而，也许你对你的主要问题有一个很好的理由：|3169210|3169211|如何在Python中制作函数的深度副本？|3169212|3169213|3169214|为了保持与Python2和3的兼容性，我建议使用函数的特殊__dunder__属性。例如：|3169215|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|3169216|下面是一个用法示例：|3169217|def+main():
++++from+logging+import+getLogger+as+_getLogger+#+pyflakes:ignore,+must+copy
++++getLogger+=+copy_func(_getLogger)
++++getLogger.__doc__+%2B=+'\n++++This+function+is+from+the+Std+Lib+logging+module.\n++++'
++++assert+getLogger.__doc__+is+not+_getLogger.__doc__
++++assert+getLogger.__doc__+!=+_getLogger.__doc__|3169218|一位评论者说：|3169219|3169220|这不适用于内置函数|3169221|3169222|3169223|对于内置函数，我不会这么做。对于用纯Python编写的函数，我几乎没有理由这样做，我怀疑如果您这样做，您可能做了一些非常错误的事情(尽管我在这里可能是错的)。|3169224|如果你想要一个函数做一个内置函数所做的事情，并重用实现，就像复制一样，那么你应该用另一个函数包装这个函数，例如：|3169225|_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)|3169226|entityMap^0|0|0|0|0|J|D|0|0|1|D|0|0|0|0|0|0|0|0|T|A|0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|-4|4|5|6|1Q|7|@]|8|@]|9|$]]|$1|A|3|B|4|C|6|1R|7|@]|8|@]|9|$]]|$1|D|3|-4|4|5|6|1S|7|@]|8|@]|9|$]]|$1|E|3|-4|4|5|6|1T|7|@]|8|@]|9|$]]|$1|F|3|G|4|5|6|1U|7|@$H|1V|I|1W|J|K]]|8|@]|9|$]]|$1|L|3|M|4|N|6|1X|7|@]|8|@]|9|$O|P]]|$1|Q|3|R|4|5|6|1Y|7|@$H|1Z|I|20|J|K]]|8|@]|9|$]]|$1|S|3|T|4|N|6|21|7|@]|8|@]|9|$O|P]]|$1|U|3|V|4|5|6|22|7|@]|8|@]|9|$]]|$1|W|3|X|4|5|6|23|7|@]|8|@]|9|$]]|$1|Y|3|-4|4|5|6|24|7|@]|8|@]|9|$]]|$1|Z|3|10|4|C|6|25|7|@]|8|@]|9|$]]|$1|11|3|-4|4|5|6|26|7|@]|8|@]|9|$]]|$1|12|3|-4|4|5|6|27|7|@]|8|@]|9|$]]|$1|13|3|14|4|5|6|28|7|@$H|29|I|2A|J|K]]|8|@]|9|$]]|$1|15|3|16|4|N|6|2B|7|@]|8|@]|9|$O|P]]|$1|17|3|18|4|5|6|2C|7|@]|8|@]|9|$]]|$1|19|3|1A|4|N|6|2D|7|@]|8|@]|9|$O|P]]|$1|1B|3|1C|4|5|6|2E|7|@]|8|@]|9|$]]|$1|1D|3|-4|4|5|6|2F|7|@]|8|@]|9|$]]|$1|1E|3|1F|4|C|6|2G|7|@]|8|@]|9|$]]|$1|1G|3|-4|4|5|6|2H|7|@]|8|@]|9|$]]|$1|1H|3|-4|4|5|6|2I|7|@]|8|@]|9|$]]|$1|1I|3|1J|4|5|6|2J|7|@]|8|@]|9|$]]|$1|1K|3|1L|4|5|6|2K|7|@]|8|@]|9|$]]|$1|1M|3|1N|4|N|6|2L|7|@]|8|@]|9|$O|P]]|$1|1O|3|-4|4|5|6|2M|7|@]|8|@]|9|$]]]|1P|$]]

<blockquote>
<h2>My goal is to have two functions with the same implementation but with different docstrings.</h2>
</blockquote>
Most users will do this, say the original function is in <code>old_module.py</code>:
<pre><code>def implementation(arg1, arg2): 
 &quot;&quot;&quot;this is a killer function&quot;&quot;&quot;
</code></pre>
and in <code>new_module.py</code>
<pre><code>from old_module import implementation as _implementation

def implementation(arg1, arg2):
 &quot;&quot;&quot;a different docstring&quot;&quot;&quot;
 return _implementation(arg1, arg2)
</code></pre>
This is the most straightforward way to reuse functionality. It is easy to read and understand the intent.
Nevertheless, perhaps you have a good reason for your main question:
<blockquote>
<h2>How can I make a deepcopy of a function in Python?</h2>
</blockquote>
To keep this compatible with Python 2 and 3, I recommend using the function's special <code>__dunder__</code> attributes. For example:
<pre><code>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
</code></pre>
And here's an example usage:
<pre><code>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__
</code></pre>
A commenter says:
<blockquote>
This can’t work for built‑in functions
</blockquote>
Well I wouldn't do this for a built-in function. I have very little reason to do this for functions written in pure Python, and my suspicion is that if you are doing this, you're probably doing something very wrong (though I could be wrong here).
If you want a function that does what a builtin function does, and reuses the implementation, like a copy would, then you should wrap the function with another function, e.g.:
<pre><code>_sum = sum
def sum(iterable, start=0):
 &quot;&quot;&quot;sum function that works like the regular sum function, but noisy&quot;&quot;&quot;
 print('calling the sum function')
 return _sum(iterable, start)
 
</code></pre>

blocks|key|260778|text|其他答案不允许使用pickle进行序列化。下面是我用来克隆函数并允许python3序列化的代码：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|260779|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)+)|code-block|syntax|javascript|260780|输出：|260781|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.'|260782|如果您使用类方法来尝试此代码片段，您可能会遇到qualname属性的问题(我认为pickle应该无法找到您的函数)。我从来没有尝试过，但是它应该很容易修复。只需查看有关qualname的文档即可|offset|length|style|BOLD|260783|entityMap^0|0|0|0|0|N|8|2C|8|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|W|8|@$M|X|N|Y|O|P]|$M|Z|N|10|O|P]]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|11|8|@]|9|@]|A|$]]]|R|$]]

The others answers do not allow for serialization with pickle. Here a code that I am using to clone a function and allow for serialization for python3:

<pre class="lang-py prettyprint-override"><code>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) )
</code></pre>

Output:

<pre><code>printing foo and the copy &lt;function IAmFooCopied at 0x7f8a6a8159d8&gt; &lt;function foo at 0x7f8a6b5f5268&gt;
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.'
</code></pre>

You may encounter problem with the qualname attribute if you try this snippet with class methods (I think pickle should fail to find your function). I never tried it, however it should be easily fixable. Just check the doc about qualname

blocks|key|260787|text|使用lambda和rest参数很容易做到：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|260788|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+%2B=+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|code-block|syntax|javascript|260789|Try+it+online!|260790|entityMap|0|LINK|mutability|MUTABLE|url|https://tio.run/##XZBBT4QwEIXv/RWT3Uu7iwbdsAciJsbEX@DNGFKXFppAi@0Y4ddjiwVxe@p73@TN5PUjNkafpqkSErqxvJh@pJLlQCC@PTxbwVEAh5Z3HxUHbDhCpzp1cSDXuRqKZeDAbe1ykHT@sE3UU1UB1yP01vTCohIOjNyEYAhRDqlULQpLY2AYz0EbBLoryx0oPVssqZT117K/FcoHpKv6blQrvPcArdAUWb6S8JxAjmhpneCbek/qKOUsN5m/uccC7lbLCvyyGurVIHt4FQ5JqNF9Wjr4CuPQcBiIt26lMf64LE1JkHPTXi@de4uR3iqNdKE0Y8x3dvMI99k1Oi/odL5CYU9kYdd/CEURzov8hbdOTNMP^0|2|6|0|0|0|E|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|X|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|Y|8|@]|D|@$9|Z|A|10|1|11]]|E|$]]|$1|M|3|-4|5|6|7|12|8|@]|D|@]|E|$]]]|N|$O|$5|P|Q|R|E|$S|T]]]]

It's quite easy to do using <code>lambda</code> and rest parameters:
<pre class="lang-py prettyprint-override"><code>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 (&quot;__&quot; in prop),dir(f)))
 i = 0
 while i &lt; 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)) # -&gt; 25
print(sqr_copy(6)) # -&gt; 36
print(sqr_copy.foo) # -&gt; 500
print(sqr_copy == sqr) # -&gt; False
</code></pre>
<a href="https://tio.run/##XZBBT4QwEIXv/RWT3Uu7iwbdsAciJsbEX@DNGFKXFppAi@0Y4ddjiwVxe@p73@TN5PUjNkafpqkSErqxvJh@pJLlQCC@PTxbwVEAh5Z3HxUHbDhCpzp1cSDXuRqKZeDAbe1ykHT@sE3UU1UB1yP01vTCohIOjNyEYAhRDqlULQpLY2AYz0EbBLoryx0oPVssqZT117K/FcoHpKv6blQrvPcArdAUWb6S8JxAjmhpneCbek/qKOUsN5m/uccC7lbLCvyyGurVIHt4FQ5JqNF9Wjr4CuPQcBiIt26lMf64LE1JkHPTXi@de4uR3iqNdKE0Y8x3dvMI99k1Oi/odL5CYU9kYdd/CEURzov8hbdOTNMP" rel="nofollow noreferrer">Try it online!</a>

I would like to make a deepcopy of a function in Python. The copy module is not helpful, according to the <a href="http://docs.python.org/library/copy.html" rel="noreferrer">documentation</a>, which says:

<blockquote>
 This module does not copy types like module, method, stack trace, stack frame, file, 
 socket, window, array, or any similar types. It does “copy” functions and classes (shallow 
 and deeply), by returning the original object unchanged; this is compatible with the way
 these are treated by the pickle module.
</blockquote>

My goal is to have two functions with the same implementation but with different docstrings. 

<pre><code>def A():
 """A"""
 pass

B = make_a_deepcopy_of(A)
B.__doc__ = """B"""
</code></pre>

So how can this be done?

How can I make a deepcopy of a function in Python?

Python

我想用Python制作一个函数的深度副本。根据的说法，复制模块没有帮助，它说：此模块不复制模块、方法、堆栈跟踪、堆栈帧、文件、套接字、窗口、数组或任何类似类型等类型。它通过原封不动地返回原始对象来“复制”函数和类(浅层和深层)；这与pickle模块处理这些函数和类的方式兼容。我的目标是拥有两个实现相同但文档字符串不同的...

问如何在Python中创建函数的深度副本？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何在Python中创建函数的深度副本？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何在Python中创建函数的深度副本？
EN