Wie cast-Objekt in Python

Es ist kein casting wie die anderen Antworten bereits erklärt. Sie können Unterklassen oder stellen geändert, neue Typen mit dem extra an Funktionalität mit Dekorateure.

Hier ist ein vollständiges Beispiel (Kredit Wie eine Kette von Funktion Dekoratoren?). Sie brauchen nicht zu ändern Ihre ursprünglichen Klassen. In meinem Beispiel die original-Klasse aufgerufen wird, zu Arbeiten.

# decorator for logging
def logging(func):
    def wrapper(*args, **kwargs):
        print func.__name__, args, kwargs
        res = func(*args, **kwargs)
        return res
    return wrapper

# this is some example class you do not want to/can not modify
class Working:
    def Do(c):
        print("I am working")
    def pr(c,printit):   # other example method
        print(printit)
    def bla(c):          # other example method
        c.pr("saybla")

# this is how to make a new class with some methods logged:
class MutantWorking(Working):
    pr=logging(Working.pr)
    bla=logging(Working.bla)
    Do=logging(Working.Do)

h=MutantWorking()
h.bla()
h.pr("Working")                                                  
h.Do()

druckt

h.bla()
bla (<__main__.MutantWorking instance at 0xb776b78c>,) {}
pr (<__main__.MutantWorking instance at 0xb776b78c>, 'saybla') {}
saybla

pr (<__main__.MutantWorking instance at 0xb776b78c>, 'Working') {}
Working

Do (<__main__.MutantWorking instance at 0xb776b78c>,) {}
I am working

Außerdem würde ich gerne verstehen, warum können Sie nicht ändern eine Klasse. Hast du das probiert? Denn, wie ein alternative um eine Unterklasse, wenn Sie dynamische fühlen Sie kann fast immer ändern, eine alte Klasse in Ort:

Working.Do=logging(Working.Do)
ReturnStatement.Act=logging(ReturnStatement.Act)

Update: Gelten logging, um alle Methoden einer Klasse

Als Sie nun speziell darum gebeten. Sie kann Schleife über alle Mitglieder und Protokollierung gelten Ihnen allen. Aber Sie brauchen, um eine Regel zu definieren, für welche Art der Mitglieder zu ändern. Das Beispiel unten schließt jede Methode mit __ in seinem Namen .

import types
def hasmethod(obj, name):
    return hasattr(obj, name) and type(getattr(obj, name)) == types.MethodType

def loggify(theclass):
  for x in filter(lambda x:"__" not in x, dir(theclass)):
     if hasmethod(theclass,x):
        print(x)
        setattr(theclass,x,logging(getattr(theclass,x)))
  return theclass

Mit dieser alles, was Sie tun müssen, um eine neue angemeldet-version der a-Klasse ist:

@loggify
class loggedWorker(Working): pass

Oder ändern einer vorhandenen Klasse in Ort:

loggify(Working)

InformationsquelleAutor Johan Lundberg

Keinen direkten Weg.

Können Sie definieren, MutantReturnStatement ist init wie diese:

def __init__(self, retStatement):
    self.retStatement = retStatement

und dann verwenden Sie es wie diese:

class MutantWorking(Working):
    def do(self):
        print "I am wrapping Working."
        # !!! this is not working, I'd need that casting working !!!
        return MutantReturnStatement(Working().do())

Und Sie sollten loswerden zu Erben ReturnStatement in Ihre wrapper, wie diese

class MutantReturnStatement(object):
    def act(self):
        print "I'm wrapping ReturnStatement."
        return self.retStatement.act()

InformationsquelleAutor Jurlie