如何读取包含默认参数值的函数签名？

尝试对一个对象调用 help来了解它。

>>> foo = [1, 2, 3]
>>> help(foo.append)
Help on built-in function append:


append(...)
L.append(object) -- append object to end

import inspect


def foo(a, b, x='blah'):
pass


print(inspect.signature(foo))
# (a, b, x='blah')

Python 3.5 + 推荐使用 inspect.signature()。

#! /usr/bin/env python


import inspect
from collections import namedtuple


DefaultArgSpec = namedtuple('DefaultArgSpec', 'has_default default_value')


def _get_default_arg(args, defaults, arg_index):
""" Method that determines if an argument has default value or not,
and if yes what is the default value for the argument


:param args: array of arguments, eg: ['first_arg', 'second_arg', 'third_arg']
:param defaults: array of default values, eg: (42, 'something')
:param arg_index: index of the argument in the argument array for which,
this function checks if a default value exists or not. And if default value
exists it would return the default value. Example argument: 1
:return: Tuple of whether there is a default or not, and if yes the default
value, eg: for index 2 i.e. for "second_arg" this function returns (True, 42)
"""
if not defaults:
return DefaultArgSpec(False, None)


args_with_no_defaults = len(args) - len(defaults)


if arg_index < args_with_no_defaults:
return DefaultArgSpec(False, None)
else:
value = defaults[arg_index - args_with_no_defaults]
if (type(value) is str):
value = '"%s"' % value
return DefaultArgSpec(True, value)


def get_method_sig(method):
""" Given a function, it returns a string that pretty much looks how the
function signature would be written in python.


:param method: a python method
:return: A string similar describing the pythong method signature.
eg: "my_method(first_argArg, second_arg=42, third_arg='something')"
"""


# The return value of ArgSpec is a bit weird, as the list of arguments and
# list of defaults are returned in separate array.
# eg: ArgSpec(args=['first_arg', 'second_arg', 'third_arg'],
# varargs=None, keywords=None, defaults=(42, 'something'))
argspec = inspect.getargspec(method)
arg_index=0
args = []


# Use the args and defaults array returned by argspec and find out
# which arguments has default
for arg in argspec.args:
default_arg = _get_default_arg(argspec.args, argspec.defaults, arg_index)
if default_arg.has_default:
args.append("%s=%s" % (arg, default_arg.default_value))
else:
args.append(arg)
arg_index += 1
return "%s(%s)" % (method.__name__, ", ".join(args))




if __name__ == '__main__':
def my_method(first_arg, second_arg=42, third_arg='something'):
pass


print get_method_sig(my_method)
# my_method(first_argArg, second_arg=42, third_arg="something")

可以说，找到函数签名的最简单方法是 help(function):

>>> def function(arg1, arg2="foo", *args, **kwargs): pass
>>> help(function)
Help on function function in module __main__:


function(arg1, arg2='foo', *args, **kwargs)

此外，在 Python 3中，向 inspect模块添加了一个名为 signature的方法，signature被设计用来表示 可调用对象的签名及其返回注释:

>>> from inspect import signature
>>> def foo(a, *, b:int, **kwargs):
...     pass


>>> sig = signature(foo)


>>> str(sig)
'(a, *, b:int, **kwargs)'


>>> str(sig.parameters['b'])
'b:int'


>>> sig.parameters['b'].annotation
<class 'int'>

可能有点晚了，但是如果您还想保持参数 以及他们的违约的顺序，那么您可以使用 抽象语法树模组(AST)。

下面是一个概念验证(注意代码对参数进行排序，并将它们与默认值进行匹配，这一点肯定可以得到改进/更加清晰) :

import ast


for class_ in [c for c in module.body if isinstance(c, ast.ClassDef)]:
for method in [m for m in class_.body if isinstance(m, ast.FunctionDef)]:
args = []
if method.args.args:
[args.append([a.col_offset, a.id]) for a in method.args.args]
if method.args.defaults:
[args.append([a.col_offset, '=' + a.id]) for a in method.args.defaults]
sorted_args = sorted(args)
for i, p in enumerate(sorted_args):
if p[1].startswith('='):
sorted_args[i-1][1] += p[1]
sorted_args = [k[1] for k in sorted_args if not k[1].startswith('=')]


if method.args.vararg:
sorted_args.append('*' + method.args.vararg)
if method.args.kwarg:
sorted_args.append('**' + method.args.kwarg)


signature = '(' + ', '.join(sorted_args) + ')'


print method.name + signature

如果您只是想打印函数，那么可以使用 pydoc。

import pydoc


def foo(arg1, arg2, *args, **kwargs):
'''Some foo fn'''
pass


>>> print pydoc.render_doc(foo).splitlines()[2]
foo(arg1, arg2, *args, **kwargs)

如果您试图实际分析函数签名，那么使用检查模块的 argspec。在将用户的 hook 脚本函数验证到一个通用框架中时，我必须这样做。

在命令行(IPython)中使用% pdef，它将只打印签名。

例如 %pdef np.loadtxt

 np.loadtxt(fname, dtype=<class 'float'>, comments='#', delimiter=None, converters=None, skiprows=0, usecols=None, unpack=False, ndmin=0, encoding='bytes')

示例代码:

import inspect
from collections import OrderedDict




def get_signature(fn):
params = inspect.signature(fn).parameters
args = []
kwargs = OrderedDict()
for p in params.values():
if p.default is p.empty:
args.append(p.name)
else:
kwargs[p.name] = p.default
return args, kwargs




def test_sig():
def fn(a, b, c, d=3, e="abc"):
pass


assert get_signature(fn) == (
["a", "b", "c"], OrderedDict([("d", 3), ("e", "abc")])
)

又迟到了。我的重点不是再次打印签名或显示帮助。它指向 程序自省函数参数(当我提到这个问题时，我希望通过查看以 request作为第一个参数名的函数来检查 Django 视图函数)。

关键是 签名，参数属性，它实际上并不复杂(请注意，inspect._empty在概念上类似于 None)。

import inspect
from typing import Any, cast


def check_signature(func : "Callable") -> None:
funcname = func.__name__
try:
# class inspect.Signature(parameters=None, *, return_annotation=Signature.empty)
# see https://docs.python.org/3/library/inspect.html#inspect.Signature
sig = inspect.signature(func)
except (ValueError,) as e:
print(f"\n\n`{funcname}` has no signature")
return
    

print(f"\n\n`{funcname}{sig}` parameters:")
for position, (name,param) in enumerate(sig.parameters.items()):
# class inspect.Parameter(name, kind, *, default=Parameter.empty, annotation=Parameter.empty)
# see https://docs.python.org/3/library/inspect.html#inspect.Parameter
print(f"  {position} {name:30.30}  kind={param.kind.description.replace(' ','_')} / default={param.default if param.default is not inspect._empty else ''} / annotation={param.annotation if param.annotation is not inspect._empty else ''}")


class Foo:
def bar(self, zoom : int =2):
pass


for func in [Any, check_signature, print, Foo.bar, Foo().bar, isinstance, issubclass, cast]:
check_signature(func)

产出:

`Any(*args, **kwds)` parameters:
0 args                            kind=variadic_positional / default= / annotation=
1 kwds                            kind=variadic_keyword / default= / annotation=




`check_signature(func: 'Callable') -> None` parameters:
0 func                            kind=positional_or_keyword / default= / annotation=Callable




`print` has no signature




`bar(self, zoom: int = 2)` parameters:
0 self                            kind=positional_or_keyword / default= / annotation=
1 zoom                            kind=positional_or_keyword / default=2 / annotation=<class 'int'>




`bar(zoom: int = 2)` parameters:
0 zoom                            kind=positional_or_keyword / default=2 / annotation=<class 'int'>




`isinstance(obj, class_or_tuple, /)` parameters:
0 obj                             kind=positional-only / default= / annotation=
1 class_or_tuple                  kind=positional-only / default= / annotation=




`issubclass(cls, class_or_tuple, /)` parameters:
0 cls                             kind=positional-only / default= / annotation=
1 class_or_tuple                  kind=positional-only / default= / annotation=




`cast(typ, val)` parameters:
0 typ                             kind=positional_or_keyword / default= / annotation=
1 val                             kind=positional_or_keyword / default= / annotation=

在 OP 的情况下，你只需要检查 param.default is not inspect._empty，而我选择返回 dict[str, Any]。

为了让事情变得容易一些，我去给整件事情加上了一个冗长的包装:

class FuncSignature(BaseModel):


class Config:
arbitrary_types_allowed = True


funcname: str
sig : inspect.Signature
by_pos : dict[int,inspect.Parameter]
by_name: dict[str,inspect.Parameter]


undefined = inspect._empty


def get_signature(func : "Callable") -> FuncSignature:
"""return signature for a function"""
funcname = func.__name__
sig = inspect.signature(func)
by_name, by_pos = {},{}


for position, (name,param) in enumerate(sig.parameters.items()):
by_name[name] = param
by_pos[position] = param


return FuncSignature(funcname=funcname, sig=sig,by_name=by_name,by_pos=by_pos)

这让我可以

def myview(request, rdbname):
pass


res = check_signature(myview)
print(res.by_pos[0].name == "request")  # True