기본 인수 값을 포함한 함수의 서명을 읽으려면 어떻게 해야 합니까?

기본 인수 값을 포함한 함수의 서명을 읽으려면 어떻게 해야 합니까?

함수 객체가 주어지면 서명을 받으려면 어떻게 해야 합니까?예를 들어, 다음과 같은 경우:

def my_method(first, second, third='something'):
    pass

나는 받고 싶습니다."my_method(first, second, third='something')".

import inspect

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

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

Python 3.5+ 권장.

함수의 서명을 찾는 가장 쉬운 방법은 다음과 같습니다.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호출 가능 개체의 서명과 반환 주석을 나타내도록 설계되었습니다.

>>> 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'>

#! /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대상에 대한 정보를 확인할 수 있습니다.

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

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

파티에 조금 늦었을 수도 있지만 인수와 기본값의 순서도 유지하려면 추상 구문 트리 모듈(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을 사용합니다.사용자의 후크 스크립트 기능을 일반 프레임워크로 검증할 때 그렇게 해야 했습니다.

명령줄(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첫 번째 매개 변수 이름으로).

키는 Signature.parameters 특성으로, 실제로는 그렇게 복잡하지 않습니다(참고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=

작전 담당자의 경우, 당신은 그냥 확인했을 것입니다.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

언급URL : https://stackoverflow.com/questions/2677185/how-can-i-read-a-functions-signature-including-default-argument-values