Das deutsche Python-Forum

cofi hat geschrieben:Willkommen im Forum!

Vergiss die Vererbung und benutze eine Factory Funktion:

Code: Alles auswählen

def create_db_connection(self, engine):
    return {'postgresql': PostgreSQL,
              'mysql': MySQL}[engine]()

Du kannst natuerlich auch bei deiner `if`-Kaskade bleiben.

Red Rooster hat geschrieben:Aber wie dann?

class Database(object):
    def __new__(cls, engine):
        if engine == 'mysql':
            cls = MySQL
        elif engine == 'pg':
            cls = PostgreSQL
        else:
            raise Exception('Unsupported engine')
        return object.__new__(cls)

class PostgreSQL(Database):
    def select(self):
        print('select for pg')

class MySQL(Database):
    def select(self):
        print('select for mysql')

db = Database(engine='mysql')
db.select()
db = Database(engine='pg')
db.select()
db = Database(engine='oracle')
db.select()

/me hat geschrieben:

Red Rooster hat geschrieben:Aber wie dann?

So vielleicht:

Code: Alles auswählen

class Database(object):
    def __new__(cls, engine):
        if engine == 'mysql':
            cls = MySQL
        elif engine == 'pg':
            cls = PostgreSQL
        else:
            raise Exception('Unsupported engine')
        return object.__new__(cls)

class PostgreSQL(Database):
    def select(self):
        print('select for pg')

class MySQL(Database):
    def select(self):
        print('select for mysql')

db = Database(engine='mysql')
db.select()
db = Database(engine='pg')
db.select()
db = Database(engine='oracle')
db.select()

Red Rooster hat geschrieben: Danke für die prompte Antwort! Ja, ich glaube das ist genau was ich gesucht habe. Kann gar nicht glauben, daß es so einfach ist

Hyperion hat geschrieben:

Red Rooster hat geschrieben: Danke für die prompte Antwort! Ja, ich glaube das ist genau was ich gesucht habe. Kann gar nicht glauben, daß es so einfach ist

Ohne den genauen Hintergrund zu kennen würde ich ja sagen, Du suchst einen ORM. Da böte sich im Python Umfeld SQLAlchemy an - es sein denn, Du willst unbedingt Deinen eigenen schreiben...

Red Rooster hat geschrieben:

/me hat geschrieben:

Red Rooster hat geschrieben:Aber wie dann?

So vielleicht:

Code: Alles auswählen

class Database(object):
    def __new__(cls, engine):
        if engine == 'mysql':
            cls = MySQL
        elif engine == 'pg':
            cls = PostgreSQL
        else:
            raise Exception('Unsupported engine')
        return object.__new__(cls)

class PostgreSQL(Database):
    def select(self):
        print('select for pg')

class MySQL(Database):
    def select(self):
        print('select for mysql')

db = Database(engine='mysql')
db.select()
db = Database(engine='pg')
db.select()
db = Database(engine='oracle')
db.select()

Danke für die prompte Antwort! Ja, ich glaube das ist genau was ich gesucht habe. Kann gar nicht glauben, daß es so einfach ist

class Database(object):
    def __new__(cls, engine):
        if engine == 'mysql':
            cls = MySQL
        elif engine == 'pg':
            cls = PostgreSQL
        else:
            raise Exception('Unsupported engine')
        return object.__new__(cls)

class PostgreSQL(Database):
    def select(self):
        print('select for pg')

class MySQL(Database):
    def select(self):
        print('select for mysql')

# ----------------------------------------------------------

class my_db(Database):
    def __init__(self, engine):
        print 'engine'

    def select(self):
        print 'select from my_db'


db = my_db('pg')
db.select()

EyDu hat geschrieben:Du musst in der __init__-Methode von my_db auch die __init__ von Database aufrufen.

Edit: In diesem Fall liegt es natürlich daran, dass du für die Engine "pg" eine Instanz von PostgreSQL erstellst, da wird natürlich die init von my_db aufgerufen.

BlackJack hat geschrieben:@Red Rooster: Du versuchst da etwas was IMHO mit einer hierarchischen Klassenhierarchie so nicht geht. Was Du willst ist ja nicht von `Database` abzuleiten, sondern von mehreren Unterklassen davon quasi gleichzeitig abzuleiten. Das ist nicht vorgesehen.

Du solltest besser aus Deiner `MyDB` einen Proxy zu einer DB-Klasse machen. Dann ist es zum Beispiel auch ganz einfach die `select()` von der konkreten Datanbankklasse aus der überschriebenen `select()` heraus aufzurufen. Wie hättest Du Dir das bei Deinem Ansatz denn vorgestellt?

BlackJack hat geschrieben:@Red Rooster: Mir ist schon klar was Du willst, das ist aber nicht so einfach möglich, weil es eben der vorgesehenen Klassenhierarchie zuwider läuft.

Den Begriff „überschreiben” solltest Du hier vielleicht nicht verwenden, weil da nichts dergleichen passiert. Du rufst den Konstruktor von `my_db` auf, was der geerbte von `Database` ist. Und dort erstellst und gibst Du ein Exemplar der beiden anderen Unterklassen, abhängig vom Argument zurück. Von `my_db` wird niemals ein Exemplar erstellt.

Und ich sage es noch einmal: Lass diese Magie bleiben und schreibe einen Proxy statt das über Vererbung lösen zu wollen. Das ist eine saubere, einfache Lösung von der man auch die Klassenhierarchie zeichnen kann ohne Probleme zu bekommen.

BlackJack hat geschrieben:@Red Rooster: Ich sehe nicht warum Du keinen Proxy daraus machen können solltest. Das Entwurfsmuster zeichnet sich ja dadurch aus, dass es nach aussen wie der Datentyp verhält, für den es als Stellvertreter und Vermittler steht. Gerade bei dynamischer Typisierung geht so etwas doch sehr problemlos durch. Das hier ist deutlich weniger magisch als was Du da versuchst:

Code: Alles auswählen

class MyDB(object):
    def __init__(self, engine):
        self.db = Database(engine)
    
    def __getattr__(self, name):
        return getattr(self.db, name)
    
    def select(self):
        print 'select for MyDB, backed by:',
        self.db.select()

Zusätzlich könnte man `Database` hier auch durch eine Fabrikfunktion ersetzen um das `__new__()` los zu werden.

Red Rooster hat geschrieben:

BlackJack hat geschrieben:@Red Rooster: Ich sehe nicht warum Du keinen Proxy daraus machen können solltest. Das Entwurfsmuster zeichnet sich ja dadurch aus, dass es nach aussen wie der Datentyp verhält, für den es als Stellvertreter und Vermittler steht. Gerade bei dynamischer Typisierung geht so etwas doch sehr problemlos durch. Das hier ist deutlich weniger magisch als was Du da versuchst:

Code: Alles auswählen

class MyDB(object):
    def __init__(self, engine):
        self.db = Database(engine)
    
    def __getattr__(self, name):
        return getattr(self.db, name)
    
    def select(self):
        print 'select for MyDB, backed by:',
        self.db.select()

Zusätzlich könnte man `Database` hier auch durch eine Fabrikfunktion ersetzen um das `__new__()` los zu werden.

Danke! Jetzt sehe ich, was Du meinst. Dann sollte ich wohl gleich aus Database eine Proxy-Klasse machen, das __new__ rausschmeißen und dann kann ich auch MyDB wieder ohne Problem von Database ableiten!
Ich hatte gar nicht gewußt, daß man __getattr__ auf eine beliebige Klasse umleiten kann!

EyDu hat geschrieben:Sagt doch die Fehlermeldung aus: self.db existiert in Database.select nicht, also wird __getattr__ aufgerufen. Das versucht auf dem Objekt self.db, welches es natürlich nicht gibt, etwas zu machen. Also wird __getattr__ aufgerufen um self.db zu finden. Den Rest kannst du dir ja vorstellen.