Jak rzutować obiekt w Pythonie

Question

Mam dwie klasy (nazwijmy je Working and ReturnStatement), których nie mogę zmodyfikować, ale chcę rozszerzyć obie z logowaniem. Sztuczka polega na tym, że metoda Working zwraca obiekt ReturnStatement, więc nowy obiekt MutantWorking zwraca również ReturnStatement, chyba że mogę go przesłać do MutantReturnStatement. Mówiąc o kodzie:

# these classes can't be changed 
class ReturnStatement(object): 
    def act(self): 
     print "I'm a ReturnStatement." 

class Working(object): 
    def do(self): 
     print "I am Working." 
     return ReturnStatement() 

# these classes should wrap the original ones 
class MutantReturnStatement(ReturnStatement): 
    def act(self): 
     print "I'm wrapping ReturnStatement." 
     return ReturnStatement().act() 

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

rs = MutantWorking().do() #I can use MutantWorking just like Working 
print "--" # just to separate output 
rs.act() #this must be MutantReturnState.act(), I need the overloaded method 

Oczekiwany wynik:
ja owijania roboczych.
Pracuję.
-
Zawijam ReturnStatement.
Jestem raportem zwrotnym.

Czy można rozwiązać problem? Jestem także ciekawy, czy problem można rozwiązać również w PHP. Dopóki nie otrzymam działającego rozwiązania, nie mogę zaakceptować odpowiedzi, więc proszę napisać działający kod, aby uzyskać akceptację.

Answer 1

Nie ma odlewania jak inne odpowiedzi już wyjaśniono. Możesz tworzyć podklasy lub modyfikować nowe typy, korzystając z dodatkowej funkcjonalności przy użyciu dekoratorów .

Oto pełny przykład (kredyt na How to make a chain of function decorators?). Nie musisz modyfikować oryginalnych klas. W moim przykładzie oryginalna klasa nazywa się Praca.

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

to wypisze

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 

Ponadto, chciałbym zrozumieć, dlaczego nie można zmodyfikować klasę. Próbowałeś? Ponieważ, jako alternatywa dokonaniem podklasy, jeśli czujesz dynamiczny ty może prawie zawsze zmodyfikować starą klasę w lokalu:

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

Aktualizacja: Zastosuj rejestrowanie wszystkich metod klasy

Jak teraz wyraźnie o to prosiliście. Możesz można pętli na wszystkich członków i zastosować rejestrowanie do nich wszystkich. Ale musisz zdefiniować regułę dla jakiego rodzaju członków do modyfikacji. Poniższy przykład wyklucza jakąkolwiek metodę z __ w nazwie.

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 

Mając to wszystko co musisz zrobić, aby nowy zalogowany wersję klasy jest:

@loggify 
class loggedWorker(Working): pass 

lub modyfikacji istniejącego klasa w lokalu:

loggify(Working) 

Answer 2

W Pythonie nie ma "rzucania". Każda podklasa klasy jest uważana za przykład jej rodziców. Pożądane zachowanie można osiągnąć poprzez odpowiednie wywołanie metod nadklasy i przez nadpisanie atrybutów klas.

Co można zrobić na przykład, ma mieć inicjator podklasy, który odbiera superklasę i kopiuje jej odpowiednie atrybuty - tak, Twój MutantReturnstatement można zapisać w następujący sposób:

class MutantReturnStatement(ReturnStatement): 
    def __init__(self, previous_object=None): 
     if previous_object: 
      self.attribute = previous_object.attribute 
      # repeat for relevant attributes 
    def act(self): 
     print "I'm wrapping ReturnStatement." 
     return ReturnStatement().act() 

a następnie zmień swoje MutantWorking klasa:

class MutantWorking(Working): 
    def do(self): 
     print "I am wrapping Working." 
     return MutantReturnStatement(Working().do()) 

Istnieje pythonic sposoby na nie o wiele self.attr = other.attr linii na metodzie __init__ jeśli istnieje wiele (jak ponad 3 :-)) atrybuty chcesz skopiować - najbardziej leniwym z nich jest po prostu skopiowanie atrybutu drugiej instancji o wartości __dict__.

Alternatywnie jeśli wiesz co robisz, można też po prostu zmienić atrybut swojego obiektu docelowego __class__ do wybranej klasy - ale to może być mylące i prowadzić do subtelnych błędów (metoda z __init__ podklasa nie zostanie wywołana, nie będzie działać na klasach innych niż python i innych możliwych problemach), nie zalecam tego podejścia - nie jest to "rzutowanie", jest to wykorzystanie introspekcji do brutalnej zmiany obiektu i jest tylko zawarte na utrzymanie pełnej odpowiedzi:

class MutantWorking(Working): 
    def do(self): 
     print "I am wrapping Working." 
     result = Working.do(self) 
     result.__class__ = MutantReturnStatement 
     return result 

Again - to powinno działać, ale nie rób tego - użyj FO metoda rmera.

Nawiasem mówiąc, nie mam zbyt dużego doświadczenia z innymi językami OO, które pozwalają na casting - ale rzuca się do podklasy, nawet w jakimkolwiek języku? Czy jest sens? Sądzę, że casting jest dozwolony tylko dla klas nadrzędnych.

Answer 3

Nie ma bezpośredniego sposobu.

Można zdefiniować MutantReturnStatement za Init tak:

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

a następnie używać go tak:

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

I należy pozbyć dziedziczeniu ReturnStatement w opakowaniu jednostkowym, jak to

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

Answer 4

You don” t potrzebujesz tu castingu. Potrzebujesz tylko

class MutantWorking(Working): 
def do(self): 
    print "I am wrapping Working." 
    Working().do() 
    return MutantReturnStatement() 

To oczywiście zapewni prawidłowy powrót i pożądany wydruk.