मैं डिफ़ॉल्ट तर्क मूल्यों सहित फ़ंक्शन के हस्ताक्षर कैसे पढ़ सकता हूं?

Question

एक फ़ंक्शन ऑब्जेक्ट को देखते हुए, मैं इसका हस्ताक्षर कैसे प्राप्त कर सकता हूं? उदाहरण के लिए, इसके लिए:

def myMethod(firt, second, third='something'):
    pass

मैं पाना चाहूंगा "myMethod(firt, second, third='something')"।

Comments

क्या आप अपने विशिष्ट प्रश्न पर विस्तार से बता सकते हैं और शायद अपेक्षित परिणाम के साथ एक उदाहरण दे सकते हैं?

— झविस्ट

संभवत: वह पायथन या तीसरे पक्ष के पुस्तकालयों में कार्यक्षमता की तलाश कर रहा है, जो विधि के नाम को देखते हुए एक विधि के हस्ताक्षर (मापदंडों के नाम और प्रकार और वापसी मूल्य) लौटाएगा।

— माइकल पेट्रोत्ता

हस्ताक्षर के रूप में यह कैसे और इस तरह से कॉल करने के लिए? help(yourmethod)जैसे प्रयास करेंhelp(map)

— निक टी

बस पैरामीटर: stackoverflow.com/questions/218616/…

— Ciro Santilli 郝海东 flow flow flow

Answer 1

import inspect

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

print(inspect.getargspec(foo))
# ArgSpec(args=['a', 'b', 'x'], varargs=None, keywords=None, defaults=('blah',))

हालाँकि, ध्यान दें inspect.getargspec() पायथन 3.0 के बाद से हटा दिया गया है।

अजगर 3.0--3.4 की सिफारिश करता है inspect.getfullargspec()।

पायथन 3.5+ अनुशंसा करता है inspect.signature()।

Comments

गुण: 'मॉड्यूल' ऑब्जेक्ट में कोई विशेषता नहीं है 'getargspec'

— Spr

@ एसपीआई, आप inspect.getargspecएक मॉड्यूल पर कॉल कर रहे हैं , एक फ़ंक्शन नहीं।

— माइक ग्राहम

धन्यवाद, समस्या ग्रहण के साथ थी जिसने निरीक्षण मॉड्यूल को नहीं देखा

— ì

यदि किसी फ़ंक्शन में तर्क एनोटेशन या कीवर्ड केवल तर्क (= यदि आप पायथन 3 का उपयोग कर रहे हैं) तो आपको getfullargspecइसके बजाय कॉल करना होगा। ( ValueError: Function has keyword-only arguments or annotations, use getfullargspec() API which can support them)

— बैड

@darth_coder: Python2 में, getargspecउठाता है TypeErrorयदि इनपुट को पायथन फ़ंक्शन के रूप में मान्यता प्राप्त नहीं है - अर्थात, पायथन में कार्यान्वित एक फ़ंक्शन। सीपीथॉन में, Exception.__init__सी में कार्यान्वित किया जाता है, इसलिए TypeError। कॉल सिग्नेचर को समझने के लिए आपको सोर्स कोड चेक करना होगा। Python3 में, getargspecअलग तरह से लागू किया जाता है, और inspect.getargspec(Exception.__init__)एक ArgSpecउदाहरण देता है ।

— unutbu

Answer 2

संभवतः किसी फ़ंक्शन के लिए हस्ताक्षर खोजने का सबसे आसान तरीका होगा 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)

इसके अलावा, पायथन 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'>

Comments

inspect.signatureयह बैकथfuncsigs प्रोजेक्ट के माध्यम से पायथन 2 के लिए भी उपलब्ध है : pypi.python.org/pypi/funcsigs

— ncoghlan

Answer 3

#! /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")

Comments

किसी भी स्पष्टीकरण के रूप में यह क्या करना चाहिए है?

— १

कोड नमूने में टिप्पणियाँ जोड़ी गईं, आशा है कि मदद करता है।

— अरूप मालाकार

लवली सामान। बेहतर होगा यदि आप इसे समायोजित करने के साथ काम करने के लिएdef foo(a, *, b:int, **kwargs)foo(4, b=3.3)

— ofer.sheffer के

Answer 4

helpइसके बारे में जानने के लिए किसी ऑब्जेक्ट पर कॉल करने का प्रयास करें ।

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

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

Answer 5

हो सकता है कि पार्टी में कुछ देर हो, लेकिन अगर आप भी तर्कों और उनकी चूक का क्रम बनाए रखना चाहते हैं , तो आप सार सिंटैक्स ट्री मॉड्यूल (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

Comments

ध्यान दें कि गैर-डिफ़ॉल्ट तर्क डिफ़ॉल्ट तर्क का पालन नहीं कर सकते हैं , इसलिए हम उन्हें केवल पूंछ से मिलान कर सकते हैं?

— इवगेनी सर्गेव

Answer 6

यदि आप सब करने की कोशिश कर रहे हैं तो फ़ंक्शन प्रिंट करें और फिर 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 का उपयोग करें। मुझे यह करना था कि जब उपयोगकर्ता की हुक स्क्रिप्ट फ़ंक्शन को सामान्य ढांचे में मान्य किया जाता है।

Answer 7

उदाहरण कोड:

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")])
    )

Answer 8

कमांड लाइन (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')