Comment puis-je définir par programmation la docstring?

J'ai un wrapper fonction qui retourne une fonction. Est-il un moyen de définir par programmation la docstring de retour de la fonction? Si je pouvais écrire à __doc__ je ferais le suivant:

def wrapper(a):
    def add_something(b):
       return a + b
    add_something.__doc__ = 'Adds ' + str(a) + ' to `b`'
    return add_something

Ensuite, j'ai pu faire

>>> add_three = wrapper(3)
>>> add_three.__doc__
'Adds 3 to `b`

Cependant, depuis __doc__ est en lecture seule, je ne peux pas le faire. Quelle est la façon correcte?

Edit: Ok, je voulais garder cela simple, mais bien sûr, ce n'est pas ce que je suis en train d'essayer de faire. Même si, en général, __doc__ est inscriptible dans mon cas, il n'est pas.

Je suis en train de créer des cas de tests pour unittest automatiquement. J'ai une fonction wrapper qui crée un objet de classe est une sous-classe de unittest.TestCase:

import unittest
def makeTestCase(filename, my_func):
    class ATest(unittest.TestCase):
        def testSomething(self):
            # Running test in here with data in filename and function my_func
            data  = loadmat(filename)
            result = my_func(data)
            self.assertTrue(result > 0)

    return ATest

Si j'ai créer cette classe et d'essayer de régler la docstring de testSomething j'obtiens une erreur:

>>> def my_func(): pass
>>> MyTest = makeTestCase('some_filename', my_func)
>>> MyTest.testSomething.__doc__ = 'This should be my docstring'
AttributeError: attribute '__doc__' of 'instancemethod' objects is not writable
  • Pourquoi ne pas simplement écrire une docstring?
  • Parce qu'alors, si vous le mettez à jour, vous devez toujours vous rappeler de mettre à jour manuellement tous les autres exemplaires dans toutes les autres fonctions wrapper
InformationsquelleAutor oceanhug | 2010-10-30
  1. 19

    J'aimerais passer la docstring dans l'usine de la fonction et de l'utilisation type construire manuellement la classe.

    def make_testcase(filename, myfunc, docstring):
    def test_something(self):
        data = loadmat(filename)
        result = myfunc(data)
        self.assertTrue(result > 0)

    clsdict = {'test_something': test_something,
               '__doc__': docstring}
    return type('ATest', (unittest.TestCase,), clsdict)

MyTest = makeTestCase('some_filename', my_func, 'This is a docstring')
    InformationsquelleAutor aaronasterling
  2. 45

    Un instancemethod obtient son docstring de son __func__. Modifier la docstring de __func__ à la place. (Le __doc__ attribut de fonctions sont accessible en écriture.)

    >>> class Foo(object):
...     def bar(self):
...         pass
...
>>> Foo.bar.__func__.__doc__ = "A super docstring"
>>> help(Foo.bar)
Help on method bar in module __main__:

bar(self) unbound __main__.Foo method
    A super docstring

>>> foo = Foo()
>>> help(foo.bar)
Help on method bar in module __main__:

bar(self) method of __main__.Foo instance
    A super docstring

    De la 2.7 docs:

    Méthodes définies par l'utilisateur

    Défini par l'utilisateur de la méthode objet combine une classe, une instance de classe (ou Aucun) et tout appelable
    objet (normalement une fonction définie par l'utilisateur).

    Spécial des attributs en lecture seule: im_self est l'instance de classe d'objet, im_func est la fonction
    objet; im_class est la classe de im_self pour les méthodes liées ou de la classe qui a demandé l'
    méthode pour unbound méthodes; __doc__ est la documentation sur la méthode (le même que
    im_func.__doc__);     __name__ est le nom de la méthode (le même que im_func.__name__);
    __module__ est le nom du module de la méthode a été définie dans, ou None si indisponible.

    Modifié dans la version 2.2: im_self utilisé pour faire référence à la classe qui définit la méthode.

    Modifié dans la version 2.6: Pour la 3.0 compatibilité im_func est également disponible en
    __func__,     et im_self comme __self__.

    InformationsquelleAutor hwiechers
  3. 6

    Suffit d'utiliser les décorateurs. Voici votre cas:

    def add_doc(value):
    def _doc(func):
        func.__doc__ = value
        return func
    return _doc

import unittest
def makeTestCase(filename, my_func):
    class ATest(unittest.TestCase):
        @add_doc('This should be my docstring')
        def testSomething(self):
            # Running test in here with data in filename and function my_func
            data  = loadmat(filename)
            result = my_func(data)
            self.assertTrue(result > 0)

    return ATest

def my_func(): pass

MyTest = makeTestCase('some_filename', my_func)
print MyTest.testSomething.__doc__
> 'This should be my docstring'

    Voici un semblable cas d'utilisation: Python aide dynamique et de saisie semi-automatique de génération de

    InformationsquelleAutor estani
  4. 6

    C'est un plus pour le fait que le __doc__ attribut des classes de type type ne peut pas être modifié. Le point intéressant est que ce n'est vrai que tant que la classe est créée à l'aide de type. Dès que vous utilisez une métaclasse vous pouvez en fait juste changer __doc__.

    L'exemple utilise l'abc (AbstractBaseClass) du module. Il fonctionne à l'aide d'un ABCMeta métaclasse

    import abc

class MyNewClass(object):
    __metaclass__ = abc.ABCMeta

MyClass.__doc__ = "Changing the docstring works !"

help(MyNewClass)

    entraînera 

    """
Help on class MyNewClass in module __main__:

class MyNewClass(__builtin__.object)
 |  Changing the docstring works !
"""

    Je suppose que ce doit être un commentaire, mais encore à ramasser mes 50 premiers points...

    InformationsquelleAutor jhp
  5. 4

    __doc__ n'est pas accessible en écriture uniquement lorsque votre objet est de type 'type'.

    Dans votre cas, add_three est une fonction et que vous pouvez simplement mettre en __doc__ à n'importe quelle chaîne.

    InformationsquelleAutor satoru
  6. 0

    Dans le cas où vous essayez de générer automatiquement unittest.Cas de test sous-classes, vous pouvez avoir plus de kilométrage primordial de leur shortDescription méthode.

    C'est la méthode qui supprime le sous-jacent docstring vers le bas de la première ligne, comme on le voit dans la normale unittest de sortie; si c'était assez pour nous donner le contrôle sur ce qu'a montré dans des outils de reporting comme TeamCity, qui était ce dont nous avions besoin.

    InformationsquelleAutor Paul Fenney