Comment une fonction d'accès à ses propres attributs?

Solution

Faire une de la de la fonction, les arguments par défaut être une référence à la fonction elle-même.

def f(self):
    return self.x
f.func_defaults = (f,)

Exemple d'utilisation:

>>> f.x = 17
>>> b = f
>>> del f
>>> b()
17

Explication

L'affiche originale voulions une solution qui ne nécessite pas un nom global de recherche. La solution la plus simple

def f():
    return f.x

effectue une recherche de la variable globale f sur chaque appel, qui ne répond pas aux exigences. Si f est supprimé, alors la fonction échoue. Le plus compliqué inspect proposition échoue de la même manière.

Ce que nous voulons, c'est d'effectuer la liaison anticipée et de stocker la référence liée à l'intérieur de l'objet lui-même. La suite est conceptuellement ce que nous faisons:

def f(self=f):
    return self.x

Ci-dessus, self est une variable locale, donc pas de mondiale recherche est effectuée. Cependant, nous ne pouvons pas écrire le code comme-est, parce que f n'est pas encore défini lorsque nous essayons de lier la valeur par défaut de self à elle. Au lieu de cela, nous avons défini la valeur par défaut après f est défini.

Décorateur

Ici est un simple décorateur de le faire pour vous. Notez que le self argument doit être le dernier, à la différence des méthodes, où self vient en premier. Cela signifie également que vous devez donner une valeur par défaut si l'un de vos arguments prendre une valeur par défaut.

def self_reference(f):
    f.func_defaults = f.func_defaults[:-1] + (f,)
    return f

@self_reference
def foo(verb, adverb='swiftly', self=None):
    return '%s %s %s' % (self.subject, verb, adverb)

Exemple:

>>> foo.subject = 'Fred'
>>> bar = foo
>>> del foo
>>> bar('runs')
'Fred runs swiftly'

Bien, nous allons regarder ce que la fonction est:

>>> def foo():
...     return x
... 
>>> foo.x = 777
>>> foo.x
777
>>> foo()
Traceback (most recent call last):
  File "<interactive input>", line 1, in <module>
  File "<interactive input>", line 2, in foo
NameError: global name 'x' is not defined
>>> dir(foo)
['__call__', '__class__', '__delattr__', '__dict__', '__doc__', '__get__', 
'__getattribute__', '__hash__', '__init__', '__module__', '__name__', '__new__', 
'__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__str__', 
'func_closure', 'func_code', 'func_defaults', 'func_dict', 'func_doc', 
'func_globals', 'func_name', 'x']
>>> getattr(foo, 'x')
777

Aha! Si l'attribut a été ajouté à la fonction d'objet, mais il ne sera pas le voir parce qu'il est à la recherche pour le mondial x à la place.

Nous pouvons essayer d'attraper le cadre de l'exécution de la fonction et de l'essayer pour voir ce qu'il y a (en gros ce que Anthony Kong l'a suggéré, mais w/o inspect module):

>>> def foo():
...     import sys
...     return sys._getframe()
... 
>>> fr = foo()
>>> dir(fr)
['__class__', '__delattr__', '__doc__', '__getattribute__', '__hash__', '__init__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__str__', 'f_back', 'f_builtins', 'f_code', 'f_exc_traceback', 'f_exc_type', 'f_exc_value', 'f_globals', 'f_lasti', 'f_lineno', 'f_locals', 'f_restricted', 'f_trace']
>>> fr.f_locals
{'sys': <module 'sys' (built-in)>}
>>> fr.f_code
<code object foo at 01753020, file "<interactive input>", line 1>
>>> fr.f_code.co_code
'd\x01\x00d\x00\x00k\x00\x00}\x00\x00|\x00\x00i\x01\x00\x83\x00\x00S'
>>> fr.f_code.co_name
'foo'

Aha! Alors peut-être que nous pouvons obtenir le nom de la fonction à partir du nom du bloc de code et puis regardez dans le rond-point moyen de l'attribut? Bien sûr:

>>> getattr(fr.f_globals[fr.f_code.co_name], 'x')
777
>>> fr.f_globals[fr.f_code.co_name].x
777
>>> def foo():
...     import sys
...     frm = sys._getframe()
...     return frm.f_globals[frm.f_code.co_name].x
... 
>>> foo.x=777
>>> foo()
777

C'est génial! Mais ne serait-il supporter le changement de nom et la suppression de la fonction d'origine?

>>> g = foo
>>> g.func_name
'foo'
>>> g.func_code.co_name
'foo'

Ah, très douteux. La fonction de l'objet et de son code objet insistent toujours sur le fait qu'ils sont appelés foo. Bien sûr, ici est l'endroit où il se casse:

>>> g.x
777
>>> g.x=888
>>> foo.x
888
>>> g()
888
>>> del foo
>>> g()
Traceback (most recent call last):
  File "<interactive input>", line 1, in <module>
  File "<interactive input>", line 4, in foo
KeyError: 'foo'

Dang! Donc, en général, il ne peut pas être fait par le biais de l'introspection par l'exécution des cadres. Les problèmes semble être qu'il y a une différence entre fonction de l'objet et code objet - code les objets sont ce qui est exécuté et c'est seulement un attribut func_code de la fonction-objet et en tant que tel n'a pas accès à la func_dict d'un attribut, d'où notre attribut x est:

>>> g
<function foo at 0x0173AE30>
>>> type(g)
<type 'function'>
>>> g.func_code
<code object foo at 017532F0, file "<interactive input>", line 1>
>>> type(g.func_code)
<type 'code'>
>>> g.func_dict
{'x': 888}

Il y a bien sûr d'autres chicane que vous pouvez faire de sorte qu'il semble que la fonction, en particulier, le truc avec la définition de la classe... mais ce n'est pas une fonction à proprement parler. Tout dépend de ce que vous avez vraiment besoin de faire avec cela.

Je doute que cela soit le meilleur moyen d'accomplir cela, mais vous pouvez accéder aux attributs à l'aide de la méthode nom de la méthode:

>>> def foo():
...   print foo.x
... 
>>> foo()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 2, in foo
AttributeError: 'function' object has no attribute 'x'
>>> foo.x = 5
>>> foo()
5

La réponse est assez simple. Utilisez simplement le fait que le nom est recherché au moment de l'exécution, pas le temps de compilation:

def f():
    return f._x

f._x = "foo"
f()           # -> "foo"

Il utilise un peu de hackish approche, mais c'est peut-être le plus correct jusqu'à présent, étant donné qu'il fonctionne avec le g() appeler ainsi. Cela fonctionne parce que c'est en s'appuyant sur ce que le bytecode de l'inspection est effectuée par le dis module, comme un raccourci.

Il ressemble plus hackish qu'elle ne l'est en partie parce que le dis.disassemble() appel imprime sur la sortie standard, donc je redirige le tout dans un StringIO. J'utilise disassemble() pour sa fonction de mise en évidence de la dernière instruction (ajouter un print text ligne là-bas pour voir à quoi il ressemble) et qui le rend plus facile à saisir de la précédente LOAD_NAME et la variable utilisée.

Il serait possible d'utiliser un nettoyeur de bytecode d'inspection de la bibliothèque de le faire sans l'aide de la dis module, mais cela prouve que c'est possible. Cela pourrait ne pas être l'approche la plus efficace, mais encore une fois peut-être cela fonctionnera dans la plupart des cas. Je n'ai pas passé assez de temps à fureter dans Python internes ou de pseudo-code binaire à savoir si la plupart des CALL_FUNCTION bytecode sont précédés immédiatement par des instructions pour que la regex astuce choisir.

import inspect
import dis
import re
import sys
import StringIO

def f():
    caller = inspect.stack()[1][0]
    sys.stdout = StringIO.StringIO()
    dis.disassemble(caller.f_code, caller.f_lasti)
    text = sys.stdout.getvalue()
    sys.stdout = sys.__stdout__
    match = re.search(r'LOAD_NAME.*\((.*?)\)\s+-->', text)
    name = match.group(1)
    try:
        func = caller.f_locals[name]
    except KeyError:
        func = caller.f_globals[name]
    return func._x

f._x = 'foo'
print 'call f():', f()
g = f
del f
print 'call g():', g()

Cela génère la sortie suivante:

call f(): foo
call g(): foo

Une autre façon d'accomplir ceci est de définir la fonction à l'intérieur d'une autre fonction, et ont l'extérieur de la fonction de retour à l'intérieur. Ensuite, la fonction interne peut accéder par le biais d'une fermeture. Voici un exemple simple:

def makeFunc():
    def f():
        return f._x
    return f

Alors:

>>> f = makeFunc()
>>> f._x = "foo"
>>> f()
'foo'
>>> g = f
>>> del f
>>> g()
'foo'

Ici est une stratégie qui est probablement pire que la func_defaults idée, mais il est intéressant néanmoins. C'est hacky mais je ne peux pas penser à quelque chose de pratiquement de mal avec elle.

Nous pouvons mettre en œuvre une fonction qui peut se référer à lui-même comme une classe avec un seul __new__ méthode (la méthode qui, normalement, crée un nouvel objet de cette classe).

class new:
    """Returns True the first time an argument is passed, else False."""
    seen = set()
    def __new__(cls, x):
        old = x in cls.seen
        cls.seen.add(x)
        return not old

def main():
    print(new(1))  # True
    print(new(2))  # True
    print(new(2))  # false
    is_new = new
    print(is_new(1))  # False

Peut-être que ce modèle pourrait être utile pour une fonction d'enregistrement...

class log_once:
    """Log a message if it has not already been logged.

    Args:
        msg: message to be logged
        printer: function to log the message
        id_: the identifier of the msg determines whether the msg
          has already been logged. Defaults to the msg itself.

    This is useful to log a condition that occurs many times in a single
    execution. It may be relevant that the condition was true once, but
    you did not need to know that it was true 10000 times, nor do you
    desire evidence to that effect to fill your terminal screen.
    """
    seen = set()
    def __new__(cls, msg, printer=print, id_=None):
        id_ = id_ or msg
        if id_ not in cls.seen:
            cls.seen.add(id_)
            printer(id_)


if __name__ == '__main__':
    log_once(1)
    log_once(1)
    log_once(2)

Je l'aime beaucoup.

from functools import update_wrapper

def dictAsGlobals(f):
    nf = type(f)(f.__code__, f.__dict__, f.__name__, f.__defaults__, f.__closure__)
    try: nf.__kwdefaults__ = f.__kwdefaults__
    except AttributeError: pass
    nf.__dict__ = f.__dict__
    nf.__builtins__ = f.__globals__["__builtins__"]
    return update_wrapper(nf, f)

@dictAsGlobals
def f():
    global timesCalled
    timesCalled += 1
    print(len.__doc__.split("\n")[0])
    return factor0 * factor1

vars(f).update(timesCalled = 0, factor0 = 3, factor1 = 2)

print(f())
print(f())
print(f.timesCalled)