Classi virtuali: farlo bene?

Question

Ho letto la documentazione che descrive l'ereditarietà della classe, le classi base astratte e persino le interfacce python. Ma niente sembra essere esattamente quello che voglio. Vale a dire, un modo semplice per costruire classi virtuali. Quando viene chiamata la classe virtuale, mi piacerebbe istanziare una classe più specifica in base a quali parametri sono assegnati e restituire la funzione di chiamata. Per ora ho un modo sommario per reindirizzare le chiamate alla classe virtuale fino alla classe sottostante.

L'idea è la seguente:

class Shape: 
    def __init__(self, description): 
     if description == "It's flat": self.underlying_class = Line(description) 
     elif description == "It's spiky": self.underlying_class = Triangle(description) 
     elif description == "It's big": self.underlying_class = Rectangle(description) 
    def number_of_edges(self, parameters): 
     return self.underlying_class(parameters) 

class Line: 
    def __init__(self, description): 
     self.desc = description 
    def number_of_edges(self, parameters): 
     return 1 

class Triangle: 
    def __init__(self, description): 
     self.desc = description 
    def number_of_edges(self, parameters): 
     return 3 

class Rectangle: 
    def __init__(self, description): 
     self.desc = description 
    def number_of_edges(self, parameters): 
     return 4 

shape_dont_know_what_it_is = Shape("It's big") 
shape_dont_know_what_it_is.number_of_edges(parameters) 

mio dirottamento è lungi dall'essere ottimale, come le chiamate solo ai number_of_edges() funzione viene passato su. L'aggiunta di qualcosa di simile per forma non cucitura a fare il trucco o:

def __getattr__(self, *args): 
    return underlying_class.__getattr__(*args) 

Quello che sto facendo male? L'intera idea è mal implementata? Qualsiasi aiuto molto apprezzato.

Answer 1

io preferirei farlo con una fabbrica:

def factory(description): 
    if description == "It's flat": return Line(description) 
    elif description == "It's spiky": return Triangle(description) 
    elif description == "It's big": return Rectangle(description) 

o:

def factory(description): 
    classDict = {"It's flat":Line("It's flat"), "It's spiky":Triangle("It's spiky"), "It's big":Rectangle("It's big")} 
    return classDict[description] 

ed ereditare le classi da Shape

class Line(Shape): 
    def __init__(self, description): 
     self.desc = description 
    def number_of_edges(self, parameters): 
     return 1 

Answer 2

È possibile cambiare la classe con object.__class__, ma è molto meglio semplicemente creare una funzione che restituisca un'istanza di una classe arbitraria.

In un'altra nota, tutti classe dovrebbe ereditare da object a meno che non si utilizza utilizzando Python 3, in questo modo, altrimenti si finisce con una classe di vecchio stile:

class A(object): 
    pass 

Answer 3

Python non ha classi virtuali fuori della scatola. Dovrai implementarli tu stesso (dovrebbe essere possibile, le capacità di riflessione di Python dovrebbero essere abbastanza potenti da permetterti di farlo).

Tuttavia, se hai bisogno di lezioni virtuali, perché non usi semplicemente un linguaggio di programmazione che ha classi virtuali come Beta, gBeta o NewsPeak? (BTW: ce ne sono altri?)

In questo caso particolare, tuttavia, non vedo come le classi virtuali possano semplificare la soluzione, almeno non nell'esempio che hai fornito. Forse potresti elaborare il motivo per cui pensi di aver bisogno di lezioni virtuali?

Non fraintendetemi: mi piacciono le lezioni virtuali, ma il fatto che solo tre lingue le abbiano mai implementate, solo una di queste tre è ancora viva e esattamente 0 di queste tre sono effettivamente utilizzate da qualcuno & hellip;

Answer 4

Sono d'accordo con TooAngel, ma vorrei usare lo __new__ method.

class Shape(object): 
    def __new__(cls, *args, **kwargs): 
     if cls is Shape:       # <-- required because Line's 
      description, args = args[0], args[1:] #  __new__ method is the 
      if description == "It's flat":   #  same as Shape's 
       new_cls = Line 
      else: 
       raise ValueError("Invalid description: {}.".format(description)) 
     else: 
      new_cls = cls 
     return super(Shape, cls).__new__(new_cls, *args, **kwargs) 

    def number_of_edges(self): 
     return "A shape can have many edges…" 

class Line(Shape): 
    def number_of_edges(self): 
     return 1 

class SomeShape(Shape): 
    pass 

---

>>> l1 = Shape("It's flat") 
>>> l1.number_of_edges() 
1 
>>> l2 = Line() 
>>> l2.number_of_edges() 
1 
>>> u = SomeShape() 
>>> u.number_of_edges() 
'A shape can have many edges…' 
>>> s = Shape("Hexagon") 
ValueError: Invalid description: Hexagon.