Wie kann eine Funktion Zugriff auf seine eigenen Attribute?

Lösung

Machen von der Funktion default-Argumente, die eine Referenz auf die Funktion selbst.

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

Beispiel:

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

Erklärung

Den original-poster wollte eine Lösung, die nicht erfordert eine Globale name-lookup. Die einfache Lösung

def f():
    return f.x

führt eine Suche aus der globalen variable f bei jedem Aufruf, welche die Anforderungen nicht erfüllt. Wenn f gelöscht wird, dann schlägt die Funktion fehl. Je komplizierter inspect Vorschlag scheitert in der gleichen Weise.

Was wir wollen, ist die Durchführung die frühe Bindung und speichern die gebundene Referenz auf das Objekt selbst. Im folgenden wird konzeptionell das, was wir tun:

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

In der oben self ist eine lokale variable, so dass keine Globale Suche ausgeführt. Wir können jedoch nicht den code schreiben, wie es ist, weil f ist noch nicht definiert, wenn wir versuchen, das binden der Standardwert self zu. Stattdessen setzen wir den Standard-Wert nach f definiert ist.

Decorator

Hier ist eine einfache Dekorateur, um dies für Sie tun. Beachten Sie, dass die self argument kommen müssen, die letzten, im Gegensatz zu Methoden, bei denen die self kommt zuerst. Dies bedeutet auch, dass Sie müssen einen default-Wert, wenn alle Ihre anderen Argumente nehmen einen default-Wert.

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)

Beispiel:

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

Gut, schauen wir uns an, was die Funktion ist:

>>> 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! Also das Attribut wurde Hinzugefügt, um die function-Objekt, aber es kann es nicht sehen, weil es ist auf der Suche nach globalen x statt.

Können wir versuchen zu greifen, den Rahmen der Ausführung der Funktion, und versuchen zu schauen, was da ist (im Grunde das, was Anthony Kong vorgeschlagen, sondern w/o - inspect Modul):

>>> 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! So können wir vielleicht den Namen der Funktion aus dem Namen der code-block und dann schauen Sie in die Runde-über den Weg für das Attribut? Sicher genug:

>>> 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

Das ist toll! Würde es aber stand die Umbenennung und Löschung der ursprünglichen Funktion?

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

Ah, sehr zweifelhaft. Die function-Objekt und den code-Objekt immer noch darauf bestehen, Sie heißen foo. Sicher genug, hier ist, wo es bricht:

>>> 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! So im Allgemeinen ist es nicht getan werden kann durch Introspektion über die Ausführung frames. Die Probleme scheint zu sein, dass es einen Unterschied gibt zwischen Funktion Objekt und code-Objekt - code-Objekte sind das, was ausgeführt wird, und ist nur ein Attribut func_code von der Funktion-Objekt und als solches hat keinen Zugriff auf die func_dict Attribut, wo unser Attribut x ist:

>>> 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}

Gibt es natürlich auch noch andere Schikanen, die Sie tun können, so dass es scheint, als Funktion, insbesondere der trick mit der definition der Klasse... aber das ist nicht eine Funktion per se. Es hängt alles davon ab, was Sie wirklich brauchen, zu tun.

Ich bezweifle, das ist die besten Weg, dies zu erreichen, aber Sie können den Zugriff auf die Attribute mithilfe der Methode name der Methode:

>>> 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

Die Antwort ist ziemlich einfach. Verwenden Sie einfach die Tatsache Namen gesucht wird zum Zeitpunkt der Ausführung nicht kompiliert Zeit:

def f():
    return f._x

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

Nutzt diese ein bisschen hackish Ansatz, aber es ist vielleicht die richtige, so weit gegeben, dass es funktioniert mit der g() Anruf auch. Es funktioniert, weil es sich auf was auch immer-bytecode-Prüfung durchgeführt wird, durch die dis Modul, wie eine Verknüpfung.

Sieht es mehr hackish, als es wirklich ist zum Teil, weil die dis.disassemble() call-prints auf stdout, also ich umleiten, die in einem StringIO. Ich benutze disassemble() für die Funktion der Hervorhebung der Letzte Befehl (fügen Sie eine print text line in dort zu sehen, wie es aussieht) und dass macht es leichter zu greifen, die bisherigen LOAD_NAME und die variable verwendet.

Wäre es möglich, verwenden Sie einen Reiniger bytecode-Inspektions-Bibliothek, dies zu tun, ohne mit der dis Modul, aber das beweist, dass es möglich ist. Dies möglicherweise nicht die am meisten robuste Methode, aber dann wieder vielleicht wird es in den meisten Fällen funktionieren. Ich habe nicht lange genug stochert in Python-Interna oder bytecode zu wissen, ob die meisten CALL_FUNCTION bytecodes werden eingeleitet sofort von Anweisungen, die der regex-trick würde herausgreifen.

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()

Dieser erzeugt die folgende Ausgabe:

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

Einen anderen Weg, dies zu erreichen, definieren Sie die Funktion innerhalb einer anderen Funktion und die äußere Funktion der inneren. Dann die innere Funktion zugreifen können sich über eine Schließung. Hier ein einfaches Beispiel:

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

Dann:

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

Hier ist eine Strategie, ist wahrscheinlich schlimmer als die func_defaults Idee, aber ist trotzdem interessant. Es ist hacky, aber ich kann nicht an nichts denken praktisch falsch mit ihm.

Können wir implementieren eine Funktion, die das verweisen auf sich selbst als eine Klasse mit einem einzigen __new__ - Methode (der Methode, die normalerweise erzeugt ein neues Objekt der Klasse).

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

Vielleicht diese Muster könnten nützlich sein, für eine logging-Funktion...

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)

Ich mag diese eine Menge.

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)