कॉल करने वाले की विधि का नाम कैसे प्राप्त किया जाता है?

Question

पायथन: कॉल करने वाले की विधि का नाम कैसे प्राप्त किया जाता है?

मान लें कि मेरे पास 2 तरीके हैं:

def method1(self):
    ...
    a = A.method2()

def method2(self):
    ...

यदि मैं मेथड 1 के लिए कोई बदलाव नहीं करना चाहता, तो मेथड 2 में कॉलर का नाम कैसे प्राप्त करें (इस उदाहरण में, नाम मेथड 1 है)?

Comments

हाँ। अब मैं सिर्फ कुछ प्रलेखन सामान और केवल परीक्षण के लिए उत्पन्न करना चाहता हूं।

— 15:20 बजे z2020

तकनीक एक चीज है, कार्यप्रणाली दूसरी है।

— 15:20 बजे z2020

अजगर में किसी अन्य फ़ंक्शन के अंदर कॉलर फ़ंक्शन नाम प्राप्त करना

— ChrisF

Answer 1

निरीक्षण.गेटफ्रेमिनफो और अन्य संबंधित कार्यों में inspectमदद कर सकता है:

>>> import inspect
>>> def f1(): f2()
... 
>>> def f2():
...   curframe = inspect.currentframe()
...   calframe = inspect.getouterframes(curframe, 2)
...   print('caller name:', calframe[1][3])
... 
>>> f1()
caller name: f1

इस आत्मनिरीक्षण का उद्देश्य डिबगिंग और विकास में मदद करना है; उत्पादन-कार्यक्षमता उद्देश्यों के लिए इस पर भरोसा करना उचित नहीं है।

Comments

"उत्पादन-कार्यक्षमता उद्देश्यों के लिए इस पर भरोसा करना उचित नहीं है।" क्यों नहीं?

— बेल्ट्सोनाटा

@beltsonata यह CPython कार्यान्वयन पर निर्भर है, इसलिए यदि आप कभी PyPy या Jython या अन्य runtimes का उपयोग करने का प्रयास करते हैं तो इसका उपयोग करने वाला कोड टूट जाएगा। यह ठीक है अगर आप स्थानीय स्तर पर विकास और डिबगिंग कर रहे हैं, लेकिन वास्तव में कुछ ऐसा नहीं है जो आप अपने उत्पादन प्रणाली में चाहते हैं।

— robru

@EugeneKrevenets सिर्फ पायथन संस्करण से परे, मैं बस इसके साथ एक मुद्दे पर भाग गया, जहां यह एक बार पेश किए गए कई मिनटों में दूसरे रन के तहत चलने वाले कोड बनाता है। यह पूरी तरह से अक्षम है

— दिमित्री

पायथन 3 के दस्तावेज़ीकरण में इसका उल्लेख क्यों नहीं किया गया है? docs.python.org/3/library/inspect.html वे कम से कम चेतावनी देते हैं कि क्या यह सही है?

इसकी शर्म की बात है कि यह प्रदर्शन पर इतनी हिट है। लॉगिंग कुछ इस तरह (या CallerMemberName ) के साथ इतना अच्छा हो सकता है ।

— स्टिंगजैक

Answer 2

छोटा संस्करण:

import inspect

def f1(): f2()

def f2():
    print 'caller name:', inspect.stack()[1][3]

f1()

(@Alex, और स्टीफन लिपन के लिए धन्यवाद )

Comments

नमस्कार, जब मैं इसे चलाता हूं, तो मुझे नीचे त्रुटि हो रही है: फ़ाइल "/usr/lib/python2.7/inspect.py", पंक्ति 528, अगर स्रोत में नहीं है तो sourcefile और फ़ाइल [0] + फ़ाइल [-1]! =! <> ': IndexError: रेंज इंडेक्स ऑफ रेंज कैन यू प्लीज सुझाव दे सकते हैं। अग्रिम में थैंक्स।

— पूजा

इस दृष्टिकोण ने मुझे एक त्रुटि दी: KeyError: ' main '

— Praxiteles

Answer 3

यह ठीक काम करने के लिए लगता है:

import sys
print sys._getframe().f_back.f_code.co_name

Comments

यह बहुत तेजी से लग रहा हैinspect.stack

— kentwait

फिर भी यह एक संरक्षित सदस्य का उपयोग करता है, जिसे आमतौर पर सलाह नहीं दी जाती है, क्योंकि sysमॉड्यूल के कुछ भारी रिफैक्टिंग होने के बाद यह विफल हो सकता है।

— filiprem

Answer 4

मैं थोड़े लंबे संस्करण के साथ आया हूं जो मॉड्यूल और क्लास सहित एक पूर्ण विधि नाम बनाने की कोशिश करता है।

https://gist.github.com/2151727 (Rev 9cccbf)

# Public Domain, i.e. feel free to copy/paste
# Considered a hack in Python 2

import inspect

def caller_name(skip=2):
    """Get a name of a caller in the format module.class.method

       `skip` specifies how many levels of stack to skip while getting caller
       name. skip=1 means "who calls me", skip=2 "who calls my caller" etc.

       An empty string is returned if skipped levels exceed stack height
    """
    stack = inspect.stack()
    start = 0 + skip
    if len(stack) < start + 1:
      return ''
    parentframe = stack[start][0]    

    name = []
    module = inspect.getmodule(parentframe)
    # `modname` can be None when frame is executed directly in console
    # TODO(techtonik): consider using __main__
    if module:
        name.append(module.__name__)
    # detect classname
    if 'self' in parentframe.f_locals:
        # I don't know any way to detect call from the object method
        # XXX: there seems to be no way to detect static method call - it will
        #      be just a function call
        name.append(parentframe.f_locals['self'].__class__.__name__)
    codename = parentframe.f_code.co_name
    if codename != '<module>':  # top level usually
        name.append( codename ) # function or a method

    ## Avoid circular refs and frame leaks
    #  https://docs.python.org/2.7/library/inspect.html#the-interpreter-stack
    del parentframe, stack

    return ".".join(name)

Comments

बहुत बढ़िया, यह मेरे लॉगिंग कोड में मेरे लिए अच्छी तरह से काम करता है, जहां मुझे बहुत सारे स्थानों से बुलाया जा सकता है। बहुत बहुत धन्यवाद।

— Little_birdie

जब तक आप भी नहीं हटाते हैं stack, तब भी यह

— सर्कुलर रेफ के

@ankostis क्या आपके पास यह साबित करने के लिए कुछ परीक्षण कोड हैं?

— अनातोली टेकटोनिक

एक टिप्पणी में दिखाने के लिए मुश्किल ... एक संपादक में कॉपी-पेस्ट यह ड्राइविंग कोड (मेमोरी से टाइप करना) और अपने कोड के दोनों संस्करणों की कोशिश करें: `` `कमजोर वर्ग को आयात करें C: पास को मार डालो (): प्रिंट ('हत्या') ) डिफेकिंग लीक (): caller_name () लोकल_वर = सी () कमजोर (स्थानीय_वार, मार) लीक () प्रिंट ("लोकल_वार को मार दिया गया होगा") `` आपको मिलना चाहिए: `` मारे गए लोकल_वर को होना चाहिए मारे गए `` `और नहीं:` `` Local_var मारे गए चाहिए मार डाला है `` `

— ankostis

बहुत बढ़िया! अन्य समाधान विफल होने पर काम किया! मैं वर्ग विधियों और लैम्ब्डा-अभिव्यक्तियों का उपयोग कर रहा हूं, इसलिए यह मुश्किल है।

— osa

Answer 5

मैं उपयोग करूंगा inspect.currentframe().f_back.f_code.co_name। इसका उपयोग पूर्व के किसी भी उत्तर में नहीं किया गया है जो मुख्य रूप से तीन प्रकारों में से एक है:

• कुछ पूर्व उत्तर उपयोग करते हैं inspect.stackलेकिन यह बहुत धीमी गति से ज्ञात होता है ।
• कुछ पूर्व उत्तर उपयोग करते हैं sys._getframe जो एक आंतरिक निजी कार्य है, जिसे इसके प्रमुख अंडरस्कोर दिए गए हैं, और इसलिए इसका उपयोग संक्षेप में हतोत्साहित किया जाता है।
• एक पूर्व उत्तर का उपयोग करता है, inspect.getouterframes(inspect.currentframe(), 2)[1][3]लेकिन यह पूरी तरह से अस्पष्ट है कि क्या [1][3]पहुंच रहा है।

import inspect
from types import FrameType
from typing import cast


def caller_name() -> str:
    """Return the calling function's name."""
    # Ref: https://stackoverflow.com/a/57712700/
    return cast(FrameType, cast(FrameType, inspect.currentframe()).f_back).f_code.co_name


if __name__ == '__main__':
    def _test_caller_name() -> None:
        assert caller_name() == '_test_caller_name'
    _test_caller_name()

ध्यान देने के cast(FrameType, frame)लिए प्रयोग किया जाता है कि ध्यान दें mypy।

---

स्वीकृति: उत्तर के लिए 1313e द्वारा पूर्व टिप्पणी ।

Answer 6

ऊपर के सामान का एक समामेलन। लेकिन यहाँ पर मेरी दरार है।

def print_caller_name(stack_size=3):
    def wrapper(fn):
        def inner(*args, **kwargs):
            import inspect
            stack = inspect.stack()

            modules = [(index, inspect.getmodule(stack[index][0]))
                       for index in reversed(range(1, stack_size))]
            module_name_lengths = [len(module.__name__)
                                   for _, module in modules]

            s = '{index:>5} : {module:^%i} : {name}' % (max(module_name_lengths) + 4)
            callers = ['',
                       s.format(index='level', module='module', name='name'),
                       '-' * 50]

            for index, module in modules:
                callers.append(s.format(index=index,
                                        module=module.__name__,
                                        name=stack[index][3]))

            callers.append(s.format(index=0,
                                    module=fn.__module__,
                                    name=fn.__name__))
            callers.append('')
            print('\n'.join(callers))

            fn(*args, **kwargs)
        return inner
    return wrapper

उपयोग:

@print_caller_name(4)
def foo():
    return 'foobar'

def bar():
    return foo()

def baz():
    return bar()

def fizz():
    return baz()

fizz()

आउटपुट है

level :             module             : name
--------------------------------------------------
    3 :              None              : fizz
    2 :              None              : baz
    1 :              None              : bar
    0 :            __main__            : foo

Comments

यह एक IndexError को बढ़ाएगा यदि आवश्यक स्टैक की गहराई वास्तविक से अधिक हो। modules = [(index, inspect.getmodule(stack[index][0])) for index in reversed(range(1, min(stack_size, len(inspect.stack()))))]मॉड्यूल प्राप्त करने के लिए उपयोग करें ।

— jake77

Answer 7

मुझे एक तरीका मिला अगर आप कक्षाओं में जा रहे हैं और चाहते हैं कि कक्षा विधि और विधि से संबंधित हो। यह थोड़ा सा निष्कर्षण कार्य करता है लेकिन यह अपनी बात बनाता है। यह पायथन 2.7.13 में काम करता है।

import inspect, os

class ClassOne:
    def method1(self):
        classtwoObj.method2()

class ClassTwo:
    def method2(self):
        curframe = inspect.currentframe()
        calframe = inspect.getouterframes(curframe, 4)
        print '\nI was called from', calframe[1][3], \
        'in', calframe[1][4][0][6: -2]

# create objects to access class methods
classoneObj = ClassOne()
classtwoObj = ClassTwo()

# start the program
os.system('cls')
classoneObj.method1()

Answer 8

#!/usr/bin/env python
import inspect

called=lambda: inspect.stack()[1][3]

def caller1():
    print "inside: ",called()

def caller2():
    print "inside: ",called()

if __name__=='__main__':
    caller1()
    caller2()
shahid@shahid-VirtualBox:~/Documents$ python test_func.py 
inside:  caller1
inside:  caller2
shahid@shahid-VirtualBox:~/Documents$