Question

Python 2.7中的这段代码在func周围创建了一个闭包，包含了par变量：

def creator(par):
    def func(arg):
        return par + arg
    return func

它可以像这样使用：

f = creator(7)
f(3)               # returns 10

在运行时，有没有办法获取定义闭包的函数的名称？那就是：只能访问f变量，我是否可以获得f函数内creator闭包定义的信息？

我正在使用Python 2.7。

Answer 1

您可以使用__qualname__代表qualified function name

def creator(par):
    def func(arg):
        return par + arg
    return func

>>> f = creator(7)
>>> f.__qualname__
'creator.<locals>.func'

Answer 2

我怀疑它不能在Python 2.7中完成，至少不能直接完成。这是函数f中漂亮打印的内容，减去一些明显不相关的条目：

>>> pprint({key: getattr(f, key) for key in dir(f)})
{'__call__': <method-wrapper '__call__' of function object at 0x7f9d22aefb18>,
 '__class__': <type 'function'>,
 '__closure__': (<cell at 0x7f9d22af1fd8: int object at 0x1311128>,),
 '__code__': <code object func at 0x7f9d22d3b230, file "<stdin>", line 2>,
 '__defaults__': None,
 '__dict__': {},
 '__doc__': None,
 '__module__': '__main__',
 '__name__': 'func',
 'func_closure': (<cell at 0x7f9d22af1fd8: int object at 0x1311128>,),
 'func_code': <code object func at 0x7f9d22d3b230, file "<stdin>", line 2>,
 'func_defaults': None,
 'func_dict': {},
 'func_doc': None,
 'func_globals': {'__builtins__': <module '__builtin__' (built-in)>,
                  '__doc__': None,
                  '__name__': '__main__',
                  '__package__': None,
                  'creator': <function creator at 0x7f9d22aefaa0>,
                  'f': <function func at 0x7f9d22aefb18>,
                  'pprint': <function pprint at 0x7f9d22aefc08>},
 'func_name': 'func'}

唯一有趣的密钥是func_closure（is __closure__）和func_code（is __code__），但都没有帮助。

闭包是cell个对象的元组，每个对象都包含封闭环境中键值对的值。 f.func_closure中只有一个值，par变量的值：

>>> repr(f.func_closure[0])
<cell at 0x7f9d22af1fd8: int object at 0x1311128>
>>> f.func_closure[0].cell_contents
7

cell不包含对闭包的创建者的引用，使用闭包的函数，甚至包含的封闭环境本身。（封闭环境的元素似乎是根据它们在cell个元组的元组中的位置来检索的。）

功能代码对象更接近，但也没有为其创建者命名。减去明显不相关的条目，它包含：

>>> pprint({k: getattr(f.func_code, k) for k in dir(f.func_code)})
{'__class__': <type 'code'>,
 '__doc__': 'code(argcount, nlocals, stacksize, flags, codestring, constants, names,\n      varnames, filename, name, firstlineno, lnotab[, freevars[, cellvars]])\n\nCreate a code object.  Not for the faint of heart.',
 'co_argcount': 1,
 'co_cellvars': (),
 'co_code': '\x88\x00\x00|\x00\x00\x17S',
 'co_consts': (None,),
 'co_filename': '<stdin>',
 'co_firstlineno': 2,
 'co_flags': 19,
 'co_freevars': ('par',),
 'co_lnotab': '\x00\x01',
 'co_name': 'func',
 'co_names': (),
 'co_nlocals': 1,
 'co_stacksize': 2,
 'co_varnames': ('arg',)}

这包含已关闭变量（'co_freevars': ('par',),）的名称，以及creator（'co_name': 'func',）内的函数名称，但不包含名称或对外部的任何引用功能

部分解决方案

如果您对两者都有引用，则有一种方法可以识别封闭函数的外部函数。 创建函数的函数代码对象将包含对已关闭函数的代码对象的引用：

>>> pprint({k: getattr(creator.func_code, k) for k in dir(creator.func_code)})
{'__class__': <type 'code'>,
 '__doc__': 'code(argcount, nlocals, stacksize, flags, codestring, constants, names,\n      varnames, filename, name, firstlineno, lnotab[, freevars[, cellvars]])\n\nCreate a code object.  Not for the faint of heart.',
 'co_argcount': 1,
 'co_cellvars': ('par',),
 'co_code': '\x87\x00\x00f\x01\x00d\x01\x00\x86\x00\x00}\x01\x00|\x01\x00S',
 'co_consts': (None,
               <code object func at 0x7f9d22d3b230, file "<stdin>", line 2>),
 'co_filename': '<stdin>',
 'co_firstlineno': 1,
 'co_flags': 3,
 'co_freevars': (),
 'co_lnotab': '\x00\x01\x0f\x02',
 'co_name': 'creator',
 'co_names': (),
 'co_nlocals': 2,
 'co_stacksize': 2,
 'co_varnames': ('par', 'func')}

您可以确定creator是[{1}}的来源，因为元组 f包含对creator.func_code.co_consts 的引用：

f.func_code

>>> f.func_code in creator.func_code.co_consts True >>> f.func_code is creator.func_code.co_consts[1] True返回的每个函数使用相同的代码对象（它们的差异存储在creator个对象中，而不是代码对象中）：

cell

因此，如果您可以缩小潜在来源，即>>> g = creator(10) >>> g.func_code is f.func_code is creator.func_code.co_consts[1] True或globals()中的值，您可以测试每一个来查看它是否是{{1}的“父级” }：

dir(some_class)

这种情况真的很糟糕，因为它并没有指向创建者，如果你已经找到它，它就会识别创建者。此外，如果有人使用f构建冒名顶替者，可能会被愚弄：

def is_creator(f, contender):
    target = f.func_code
    try:
        constants = contender.func_code.co_consts
    except AttributeError:
        return False
    for constant in constants:
        if constant is target:
            return True
    return False

def find_creators(f, contenders):
    for contender in contenders:
        if is_creator(f, contender):
            yield contender
    return

>>> is_creator(f, creator)
True
>>> is_creator(g, creator)
True

>>> is_creator(f, max)
False
>>> is_creator(f, g)
False
>>> is_creator(f, 'Seriously?')
False
>>> is_creator(f, None)
False

>>> list(find_creators(f, globals().values()))
[<function creator at 0x7f9d22aefaa0>]

>>> builtins = [getattr(__builtins__, s) for s in dir(__builtins__)]
>>> list(find_creators(f, builtins))
[]

可疑的改进

还有其他线索，一旦找到潜在的创造者，但它们并不真正构成证据。例子包括：

隐藏变量creator.__code__的名称在def impostor(bogus): def need_a_free_variable_in_impostors_func_code(unused): return bogus - unused return need_a_free_variable_in_impostors_func_code >>> creator(3)(7) 10 >>> impostor(3)(7) -4 >>> is_creator(f, impostor) False >>> impostor.__code__ = creator.__code__ >>> impostor(3)(7) 10 >>> is_creator(f, impostor) True >>> list(find_creators(f, globals().values())) [<function creator at 0x7f9d22aefaa0>, <function impostor at 0x7f9d1bf7f8c0>]中显示为自由变量，在'par'中显示为“单元格”变量：

creator的名称（>>> f.func_code.co_freevars[0] in creator.func_code.co_cellvars True，而非f）出现在创建者的功能代码对象中。（函数代码对象是不可变的，因此'func'必须是创建时分配给'f'的原始名称。从那时起，f.func_code.co_name可能会被重新分配。那么f ---可能是整个代码对象---但这种情况并不常见。）

f.__name__

因为函数定义可以深度嵌套 - 意味着最内层函数中的不同自由变量可以在不同的外部函数中定义（记录在f.func_code中） - 我不认为添加对这些函数的检查会让>>> f.func_code.co_name in creator.func_code.co_varnames True任何“更聪明”。

如何确定创建闭包的函数？

2 个答案:

部分解决方案

可疑的改进