Jak wydrukować Docstring funkcji Pythona z wnętrza samej funkcji?

To powinno zadziałać(w moich testach tak jest, także wyjście). Prawdopodobnie mógłbyś użyć __doc__ zamiast getdoc, ale podoba mi się, więc właśnie tego użyłem. Nie wymaga to również znajomości nazw klasy / metody / funkcji.

Przykłady zarówno dla klasy, metody i funkcji. Powiedz mi, czy to nie to, czego szukałeś:)

from inspect import *

class MySelfExplaningClass:
    """This is my class document string"""

    def __init__(self):
        print getdoc(self)

    def my_selfexplaining_method(self):
        """This is my method document string"""
        print getdoc(getattr(self, getframeinfo(currentframe()).function))


explain = MySelfExplaningClass()

# Output: This is my class document string

explain.my_selfexplaining_method()

# Output: This is my method document string

def my_selfexplaining_function():
    """This is my function document string"""
    print getdoc(globals()[getframeinfo(currentframe()).function])

my_selfexplaining_function()

# Output: This is my function document string

To działa:

def my_function():
  """Docstring for my function"""
  #print the Docstring here.
  print my_function.__doc__

my_function()

W Pythonie 2.7.1

To również działa:

class MyClass(object):
    def my_function(self):
        """Docstring for my function"""
        #print the Docstring here, either way works.
        print MyClass.my_function.__doc__
        print self.my_function.__doc__


foo = MyClass()

foo.my_function()

To jednak nie zadziała samo:

class MyClass(object):
    def my_function(self):
        """Docstring for my function"""
        #print the Docstring here.
        print my_function.__doc__


foo = MyClass()

foo.my_function()

NameError: globalna nazwa 'my_function' nie jest zdefiniowana

Jest na to dość prosta metoda, o której nikt jeszcze nie wspomniał:

import inspect

def func():
    """Doc string"""
    print inspect.getdoc(func)

Używam tego z docopt dla punktów wprowadzania skryptów konsoli.

Postawiłeś swoje pytanie jak metodę klasową, a nie jak funkcję. Przestrzenie nazw są tutaj ważne. Dla funkcji print my_function.__doc__ jest w porządku, ponieważ my_function znajduje się w globalnej przestrzeni nazw.

Dla metody klasowej, wtedy print self.my_method.__doc__ byłoby to droga do zrobienia.

Jeśli nie chcesz podawać nazwy metody, ale raczej przekazać do niej zmienną, możesz użyć wbudowanych funkcji hasattr (object,attribute) i getattr (obj, attr), które robią to, co mówią, umożliwiając przekazywanie zmiennych za pomocą ciągi będące nazwą metody. np.

class MyClass:
    def fn(self):
        """A docstring"""
        print self.fn.__doc__ 

def print_docstrings(object):
   for method in dir( object ):
       if method[:2] == '__':  # A protected function
           continue
       meth = getattr( object, method )
       if hasattr( meth , '__doc__' ):
           print getattr( meth , '__doc__' )

x = MyClass()
print_docstrings( x )

Jak zauważono wiele razy, użycie nazwy funkcji jest dynamicznym wyszukiwaniem w katalogu globals (). Działa tylko w module definicji i tylko dla funkcji globalnej. Jeśli chcesz dowiedzieć się o łańcuchu doc funkcji członka, musisz również wyszukać ścieżkę z nazwy klasy - co jest dość kłopotliwe, ponieważ nazwy te mogą być dość długie:

def foo():
    """ this is foo """
    doc = foo.__doc__
class Foo:
    def bar(self):
       """ this is bar """
       doc = Foo.bar.__doc__

Jest równoważne

def foo():
    """ this is foo """
    doc = globals()["foo"].__doc__
class Foo:
    def bar(self):
       """ this is bar """
       doc = globals()["Foo"].bar.__doc__

Jeśli chcesz sprawdzić ciąg doc rozmówcy, to i tak nie będzie działać jako twój Print-helper może żyć w zupełnie innym module z zupełnie innym słownikiem globals (). Jedynym prawidłowym wyborem jest zajrzenie do ramki stosu - ale Python nie podaje wykonywanego obiektu funkcji, ma tylko odniesienie do obiektu kodu "f_code". Ale kontynuuj, ponieważ jest również odniesienie do "f_globals" tej funkcji. Więc możesz napisać funkcję, aby uzyskać Doc rozmówcy w ten sposób, a jako wariację od niego, masz swój własny doc sznurek.

import inspect

def get_caller_doc():
    frame = inspect.currentframe().f_back.f_back
    for objref in frame.f_globals.values():
        if inspect.isfunction(objref):
            if objref.func_code == frame.f_code:
                return objref.__doc__
        elif inspect.isclass(objref):
            for name, member in inspect.getmembers(objref):
                if inspect.ismethod(member):
                    if member.im_func.func_code == frame.f_code:
                        return member.__doc__

I chodźmy to przetestować:

def print_doc():
   print get_caller_doc()

def foo():
   """ this is foo """
   print_doc()

class Foo:
    def bar(self):
       """ this is bar """
       print_doc()

def nothing():
    print_doc()

class Nothing:
    def nothing(self):
        print_doc()

foo()
Foo().bar()

nothing()
Nothing().nothing()

# and my doc

def get_my_doc():
    return get_caller_doc()

def print_my_doc():
    """ showing my doc """
    print get_my_doc()

print_my_doc()

Wyniki w tym wyjściu

 this is foo 
 this is bar 
None
None
 showing my doc 

Właściwie, większość ludzi chce mieć własny ciąg doc tylko po to, aby przekazać go jako argument, ale wywołana funkcja helpera może sam go wyszukać. Używam tego w moim kodzie unittest, gdzie jest to czasami przydatne do wypełnienia niektórych dzienników lub do użycia ciągu doc jako danych testowych. To jest powód, dla którego przedstawiona get_caller_doc () szuka tylko globalnych funkcji testowych i funkcji Członkowskich Klasa testowa, ale to chyba wystarczy dla większości osób, które chcą się dowiedzieć o Doc string.

class FooTest(TestCase):
    def get_caller_doc(self):
        # as seen above
    def test_extra_stuff(self):
        """ testing extra stuff """
        self.createProject("A")
    def createProject(self, name):
        description = self.get_caller_doc()
        self.server.createProject(name, description)

Aby zdefiniować właściwy get_frame_doc (ramka) z sys._getframe (1) jest pozostawione do reader().

Try:

class MyClass():
    # ...
    def my_function(self):
        """Docstring for my function"""
        print MyClass.my_function.__doc__
        # ...

(*) brakowało dwukropka (:) po my_function()

Wstawianie print __doc__ tuż po deklaracji klasy, przed def __init__, wyświetli ciąg doc do konsoli za każdym razem, gdy zainicjujesz obiekt z klasą